Testing for equality

Kotlin has several ways to test for equality (“Is this value the same as that value?”). None of these ways is the first thing you'd think of doing. In particular, to find out whether variable a is equal to variable b, you don't write if (a = b). Instead, you use a double equal sign (==). You write if (a == b). In Kotlin, the single equal sign (=) is reserved for assignment. So val n = 5 means “Let n stand for the value 5.”

Comparing two strings is yet another story. When you compare two strings with one another, you don't want to use the double equal sign. Using the double equal sign would ask, “Is this string stored in exactly the same place in memory as that other string?” That’s usually not what you want to ask. Instead, you usually want to ask, “Does this string have the same characters in the same order in it as that other string?” To ask the second question (the more appropriate question), Kotlin’s String type has a method named equals:

if (response.equals("yes")) {

The equals method compares two strings to see whether they have the same characters in them. In this paragraph's tiny example, the variable response refers to a string, and the text "yes" refers to a string. The condition response.equals("yes") is true if response refers to a string whose letters are 'y', and then 'e', and then 's'.

Like most programming languages, Kotlin has the usual complement of comparison operators (such as < for “less than”) and logical operators (such as && for “and”). For a list of such operators, visit https://kotlinlang.org/docs/reference/keyword-reference.html.

There are times when you do want to verify that two variables point to the same object, a condition called referential equality. In this case, you use the === operator (or the !== operator if you want to verify that they don't point to the same object). For example, in the following code, a and b point to the same object, so the output of the referential equality comparison is true:

fun main(args: Array<String>) {
val a: String = "A String Value"
val b = a
println(a === b)
}

Because Kotlin spends so much time ensuring that null values appear only in the right place, you also use a special !! operator to verify that a nullable object isn't equal to null. This particular kind of check is called an assertion. Kotlin asserts whether a is equal to null. You use this operator before performing a task that would fail with a null value, such as obtaining the length of a string, as shown here:

fun main(args: Array<String>) {
val a: String? = "A String Value"
println(a!!.length)
}

This particular form will raise an exception when a equals null. If you don't want to raise an exception, you use the Elvis operator (?:) form, shown here:

fun main(args: Array<String>) {
val a: String? = null
println(a?.length ?: 0)
}

In this case, Kotlin first checks whether a equals null. If so, it outputs a value of 0, rather than trying to obtain the length of a.

Choosing among many alternatives (Kotlin when statements)

We'll bet you were expecting something about the switch statement here. Most languages use some type of switch statement to choose from many alternatives, but a switch statement can be extremely limited. What a switch statement does is replace a series of if…else statements with a single statement. You compare a single value with one or more constants, and there is only one word for the situation: boring. A when structure is so much more flexible, for these reasons:

• You can use it as an expression or a statement (returning a value or not).
• The design is safer in that it's harder to have unexpected outcomes (such as leaving out a break clause).
• The conditions can be expressions rather than just constants.
• You have no need for an argument if you don’t have one to provide.

Here’s a basic when statement:

fun main(args: Array<String>) {
val a = 5

when (a) {
0, 1, 2, 3, 4 -> println("Less than 5")
5 -> println(5)
else -> print("Greater than 5")
}
}

The code begins by providing an argument, a, which equals 5. It then checks a against the values 0 through 4 and the precise value 5, and it includes a clause to use when all else fails: else. If you have worked with other languages and relied on a switch statement, you immediately notice that

• The when statement is more concise.
• You can separate multiple choices using a comma.

The when statement isn't limited to constants. This version of the previous example uses an expression (a range) in place of individual constants. It also checks to determine whether the argument is an Int:

when (a) {
in 0..4 -> println("Less than 5")
is Int -> println("It's an Int")
5 -> println(5)
else -> print("Greater than 5")
}

You might expect multiple outputs in this case because two of the conditions are true, but you see only the first one, "It's an Int", as output. The order of branches in your when statement is important when it's potentially possible for multiple conditions to be true under certain circumstances. The ability to have multiple true conditions can also lead to bugs, so you need to structure your when structures carefully.

The expression form of when works much like the expression form of if, except you're looking at multiple conditions:

fun main(args: Array<String>) {
val a = 5

val result: Any = when (a) {
in 0..4 -> "Less than 5"
5 -> 5
else -> false
}

println(result)
}

Depending on the value of a, result could contain a String, Int, or Boolean. The use of the Any type enables you to receive the most appropriate value type. Type casting would let you convert the value to what you need in given situations.

The expression form of when always requires an else clause unless the compiler can determine that the other clauses cover every contingency. For example, this expression form of when doesn't require an else clause:

fun main(args: Array<String>) {
val a = false

val result = when (a) {
true -> "The value is true."
false -> "The value is false."
}

println(result)
}

The expression form of when can also appear as part of a function. Consider this example in which the expression form of when forms the body of a function used to check data type:

fun main(args: Array<String>) {
println(checkType(3))
println(checkType(true))
println(checkType("Hello"))
println(checkType(arrayOf(1, 2, 3)))
}

fun checkType(x: Any) = when (x) {
is String -> "Value is a String."
is Int -> "Value is an Int."
is Boolean -> "Value is a Boolean."
else -> "Value isn't a usable type."
}

Another use of when is to check various conditions without an argument, which is quite frankly mind boggling. You use it to choose an action based on likely conditions, with the most likely or most desirable conditions first in the list. Here is a basic example:

fun main(args: Array<String>) {
val a = 5
val b = "Goodbye"
val c = true

when {
a - 1 > 5 -> println("a is greater than 5")
b == "Hello" -> println("Hello There!")
c is Boolean -> println("c is ${c}")
else -> println("None of the conditions is true.")
}
}

In this case, no argument is supplied because none is needed. The code checks each condition in turn and provides the desired output. Note that you can include math or other kinds of expressions as part of the conditions. Kotlin will perform the required manipulation before it determines the truth value of a particular condition. The only real requirement is that the condition eventually valuate to a Boolean.

Kotlin while statements

A while statement has the following form:

while (condition) {
statements to be executed
}

You can omit the curly braces when the loop has only one statement to be executed.

A traditional while statement performs a task while a condition remains true. The following loop counts down from 5 through 1:

fun main(args: Array<String>) {
var a = 5

while (a > 0) {
println(a)
--a
}
}

Each time the loop executes, the --a statement reduces the value of a by 1. Note that this is a prefix form; you could also use a-=1 to reduce the value by 1. You don't see a 0 in the output because the condition is a > 0, and the condition is checked before the println(a) statement is executed. The while statement has no expression form, so you won't ever see a variable made equal to a while statement as you can with the if or when expressions.

In an Android app, a content provider feeds a cursor to your code. You can think of the cursor as a pointer to a row in a table. In Listing 4-3, each table row has three entries: an _id, a name, and an amount. Supposedly, the _id uniquely identifies a row, the name is a person's name, and the amount is a huge number of dollars owed to you by that person.

LISTING 4-3: A while Loop

cursor.moveToFirst()

while (!cursor.isAfterLast()) {
val _id: String = cursor.getString(0)
val name: String = cursor.getString(1)
val amount: String = cursor.getString(2)
textViewDisplay.append(_id + " " +
name + " " + amount + " ")
cursor.moveToNext()
}

A cursor's moveToFirst method makes the cursor point to the first row of the table. Regardless of the row a cursor points to, the cursor's moveToNext method makes the cursor point to the next row of the table. The cursor's isAfterLast method returns true when, having tried to move to the next row, it finds that there is no next row.

In Kotlin, an exclamation point (!) means “not,” so while (!cursor.isAfterLast()) means “while it's not true that the cursor has reached past the table's last row …” So the loop in Listing 4-3 repeatedly does the following:

As long as the cursor has not reached past the last row,
get the string in the row's initial column and
make _id refer to that string,
get the string in the row's middle column and
make name refer to that string,
get the string in the row's last column and
make amount refer to that string, and
append these strings to the textViewDisplay, and then
move the cursor to the next row in preparation
for returning to the top of the while statement.

Imagine that a particular cursor's table has 100 rows. Then a processor executes the statements inside Listing 4-3's while loop 100 times. Using the official developer lingo, the processor performs 100 loop iterations.

In Listing 4-3, the characters form an escape sequence. When you put inside a string, you're escaping from the normal course of things by displaying neither a backslash nor a letter n. Instead, in a Java string always means “Go to the next line.” So in Listing 4-3, puts a line break between one _id, name, amount group and the next.

Kotlin do statements

Kotlin provides a second form of the while statement called the do statement. Unlike the while statement, which may execute only once, a do statement will always execute at least one time because the condition is checked at the end of the loop, rather than at the beginning of the loop. A do statement has the following form:

do {
statements to be executed
} while (condition)

The following example shows how the do statement works by setting a variable to a value that won't meet conditions.

fun main(args: Array<String>) {
var a = 0

do {
println(a)
--a
} while (a > 0)
}

The example outputs a 0 but then stops. Even though the value of a at the outset doesn't meet the condition while (a > 0), the loop executes once anyway.

To find a particular row of a cursor's table, you normally do a query. (For straight talk about queries, see Book 4.) You almost never perform a do-it-yourself search through a table's data. But just this once, look at a loop that iterates through row after row. The loop is in Listing 4-4.

LISTING 4-4: Leap Before You Look

cursor.moveToFirst()
name: String = ""

do {
val _id: String = cursor.getString(0)
name = cursor.getString(1)
val amount: String = cursor.getString(2)
textViewDisplay.append(_id + " " +
name + " " + amount + " ")
cursor.moveToNext()
} while (!name.equals("Burd") && !cursor.isAfterLast())

In Listing 4-4, you're looking for a row with the name Burd. (After all, the bum owes you lots of money.) When you enter the loop, the cursor points to the table's first row. Before checking a row for the name Burd, you fetch that first row's data and add the data to the textViewDisplay where the user can see what's going on.

Before you march on to the next row (the next loop iteration), you check a condition to make sure that another row is worth visiting. (Check to make sure that you haven't yet found that Burd guy, and that you haven't moved past the last row of the table.)

To get the code in Listing 4-4 working, you have to move the declaration of name outside the do statement. A declaration that's inside a pair of curly braces (such as the _id, name, and amount declarations in Listing 4-3) cannot be used outside curly braces. So, in Listing 4-4, if you don't move the name declaration outside the loop, Java complains that !name.equals("Burd") is incorrect.

Also note the use of the && (AND) operator. The while (!name.equals("Burd") && !cursor.isAfterLast()) expression has two conditions: !name.equals("Burd") and !cursor.isAfterLast(). Both conditions must be true for the do loop to continue processing. If you had used the || (OR) operator instead, the loop would continue to run as long as one of the two conditions was true.

Arrays in Kotlin

An array is a bunch of values placed in a single object. When working with a Kotlin array, what you're really doing is working with a class that stores information, not a primitive construct as found in other languages. Kotlin arrays are extremely flexible depending on how you declare them. For example, here’s a basic Kotlin array containing mixed types:

fun main(args: Array<String>) {
var myArray = arrayOf(1, 2, true, false, "Hello")
println(myArray[1])
}

The object myArray now contains five members: two Int values, two Boolean values, and a String. To access a particular element in the array, you provide the array name, followed by an index in square brackets. The output of this example is 2 because Kotlin arrays are zero-based. So, myArray[1] is actually the second array element.

An array can also accept input from expressions. Here is an example that fills the variable byThree with the values 1 through 3 and then repeats the process.

fun main(args: Array<String>) {
var byThree = Array(6) {i -> (i % 3) + 1}
println(byThree[3])
}

The output is 1 in this case. The example uses a lambda expression, which you find explained in detail in Chapter 6 of this minibook. The value i is the current index, starting with 0 and going through 5. Therefore, (i % 3) + 1 is the remainder of the index divided by 3 and with 1 added.

Now that you have a basic idea of what arrays are, you can look at a few details. The following sections give some specifics that you'll find handy while creating your Android apps.

Kotlin's for statements

Kotlin doesn’t have a for statement of the type used with other programming languages in which you define a variable to keep track of a specific number of loop iterations. When the variable meets a certain criterion, the loop stops, so basically you can say, “Execute this loop five times and then stop.” Instead, Kotlin relies on a for statement that uses an iterator, as described in the introduction to this section. Essentially, an iterator makes it easy to access members of an object one item at a time, but you don't have to know how many times at the outset. As with a standard for loop, however, the loop executes a fixed number of times and then stops. The following sections describe how the Kotlin for statements work.

Looping using Kotlin recursion

When working with standard loops, each iteration of the loop depends on the previous iteration. Consequently, it's difficult to perform looping in a multiprocessing environment because of the element of state, the recording of loop conditions, in each iteration. One of the goals of functional programming is to enable you to split up everything in an app so that each part can execute on a different processor. Although this might not seem a very laudable goal with the kinds of examples you see in this book, it’s an essential element of higher-end apps that perform machine learning or deep learning tasks (among other things). In these environments, developers often use GPUs instead of CPUs to perform processing, and some of the GPU cards used contain hordes of processors. (The NVidia Titan V contains 5,120 CUDA core; see https://www.nvidia.com/en-us/titan/titan-v/.) Consequently, you need another way to perform looping, which is where recursion comes into play. However, even in an Android app, the ability to break up a problem into very small pieces for execution on separate processors can be important, especially when it comes to games.

Chapter 6 of this minibook delves more deeply into recursion, but for now, take a look at a simple example:

fun main(args: Array<String>) {
val numbers = (2..10)

LoopIt(numbers, numbers.count() - 1)
}

fun LoopIt(range: Iterable<Any>, posit: Int) {
if (posit >= 0) {
LoopIt(range, posit - 1)
println(range.elementAt(posit))
} else {
println("All elements visited!")
}
}

The actual display of values occurs in the LoopIt() function. The idea is that you can't display multiple range values — you can display only one range value using println(range.elementAt(posit)). So, you must work through the range until you get to the first element and then display each single element in turn until you reach the end. The LoopIt(range, posit - 1) call keeps calling LoopIt() one element position at a time until it reaches the beginning of the range: element 0.

The amazing thing is that each of these calls is separate and the variables are val, which means they can't change. Until the code reaches element 0, the LoopIt(range, posit - 1) call doesn’t return; instead, it keeps moving forward in a circle until it reaches its destination. When the code does reach element 0, it prints the message "All elements visited!". What you see as output is

All elements visited!
2
3
4
5
6
7
8
9
10

Working with break and continue

Sometimes a loop condition that you didn't expect or want to avoid will occur. The condition isn’t necessarily an error, but it’s just not what you wanted. In this case, you need to perform a structural jump. Kotlin provides three such jumps:

• continue: The loop stops at its current point of processing and continues with the next loop iteration. This type of jump allows processing to continue, even if you want to avoid a particular condition.
• break: The loop exits at its current point of processing and continues with the next statement in the current function. You use this kind of jump when a condition will make further loop processing pointless, but you want to continue with the current processing instructions.
• return: The loop exits at its current point of processing and returns to the caller. You use this kind of jump when a condition will prevent further processing in a called function, but the condition isn't necessarily an error — it’s just unexpected or unwanted.

You use continue or break in any loop, whether the code exists in the current function or in a called function. Here's an example of using continue and break in a for loop:

fun main(args: Array<String>) {
val numbers = (2..10)

for (number in numbers) {
if (number == 3) continue
if (number == 8) break
println(number)
}
println("The loop has ended.")
}

The output from this example is

2
4
5
6
7
The loop has ended.

Notice that the println(number) call doesn't occur for 3 because the loop continues with the next iteration: if (number == 3) continue. Even though the loop could continue processing values beyond 7, the loop ends at 7 because of the call to if (number == 8) break. Always remember that break implies that you want to break out of the loop and continue implies that you want to continue processing the loop.

The return jump works a bit differently from continue or break. Here's an example of return:

fun main(args: Array<String>) {
val numbers = (2..10)

processData(numbers)
println("The call has returned.")
}

fun processData(numbers: IntRange) {
for (number in numbers) {
if (number == 8) return
println(number)
}
println("The loop has ended.")
}

In this case, the jump occurs in a called function, processData(). You see the values 2 through 7 output, but when the value reaches 8, the code calls return. The example never displays "The loop has ended.", as it would when break is called. Instead, the entire processData() function ends and the call returns to main().

If the return call had happened in main(), the app would have stopped, which would be confusing to your user, so you should avoid using return unless absolutely necessary.

Considering the collection types

Kotlin doesn’t actually support many native collection types. You have three choices, as described here:

• List: An ordered collection of items in which item values can appear more than once and each value is accessed by a unique index. You would use a List to hold the individual words in a sentence, for example, when order is important.
• Set: A collection of unique items in which each value is accessed by an index, but the order of the items is unimportant. You would use a Set to hold the letters of the alphabet or the numbers 0 through 9, for example.
• Map: A collection of key and value pairs in which the keys are ordered and unique, while the values need not be unique. Each key points to a specific value, even when that value is the same as some other value in the Map. Another term for a Map is a dictionary. You often see a Map used to store logical connections between items, such as locations on a map or the hierarchy in an organization.

However, these three choices aren't the extent of your options. Kotlin provides Java interoperability, so this is one place where you may need to go the Kotlin version of the Java route to make things work. With this idea in mind, you also have these Java-specific options:

Using a Kotlin-specific implementation when possible is always preferable. In fact, the compiler often warns you when you attempt to use a Java collection when a Kotlin version is available. The Kotlin implementation provides additional flexibility and more safeguards than the Java version. Here is a Kotlin implementation of a Map:

val myMap = mapOf("Yellow" to 1, "Green" to 2, "Blue" to 3)

for ((Key, Value) in myMap) {
println("The value $Value is associated with $Key.")
}

Notice that when you create a Map, you must associate a key, such as "Yellow", with a value, such as 1. Likewise, when iterating through a Map, you obtain both a key and a value for each loop.

As previously mentioned, sometimes you need to use a Java collection when Kotlin doesn't provide what you need. One of the most common Java collections you use is the Stack. A Stack pushes new values into the collection and pops them back off the top, which makes this is a last-in/first-out (LIFO) collection. Here is an example of a Java Stack implemented in Kotlin:

import java.util.Stack

fun main(args: Array<String>) {
val myStack = Stack<String>()

myStack.push("Hello")
myStack.push("Goodbye")
myStack.push("Yesterday")

println(myStack.count())
println(myStack.pop())
}

The example begins by importing the proper collection from java.util, which is a Stack in this case. You use the standard Kotlin approach to creating a new Stack, but you must make sure to specify the data type that will appear in the Stack or the compiler will complain. Theoretically, you can use the Any type with a Java collection.

To add a new item to myStack, you call the push() function with whatever value you want to add. You determine the number of items on the stack by calling count(). To remove an item, you call pop(), and the value is provided as a return.

Differentiating between read-only and mutable collections

By default, Kotlin collections are immutable, meaning read-only. After you create the collection, you can't add, subtract, or change values. For example, the documentation for List at https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-list/index.html contains all sorts of methods for searching, selecting, and otherwise stretching the List in every conceivable direction, but the data remains the same. You can obtain part of the data and put it into a new List, but the current List is immutable.

Making a collection immutable lets you work with the collection in ways that aren't possible when you use a mutable collection. If you know that the collection won’t ever change, you can offload processing to a bunch of processors and not really care which processor does what. When working with huge datasets, the ability to use multiple processors outweighs almost every other consideration. Even with smaller apps of the sort you create for Android, the speed difference of using an immutable collection can be noticeable, but there is the penalty of never being able to change the collection content to pay. Of course, this may be a nonissue if the data you’ve collected, such as a list of states in the U.S., isn’t likely to change. Here’s an example of an immutable List:

val myList = listOf(1, 2, 3, 4, 5)
for (item in myList) println(item)

Oddly enough, using an immutable List is also more secure than using the mutable version. Because no one can modify the List content, it becomes harder for someone to suddenly decide to make your life interesting with unauthorized changes.

A MutableList offers the flexibility of being able to grow or reduce the size of the collection and to change collection items. When you look at the documentation for MutableList at https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-mutable-list/index.html, you see all sorts of functions to modify the list content. Here is an example of a MutableList:

val myList = mutableListOf(1, 2, 3, 4, 5)
myList.add(6)
myList.set(2, 20)
myList.remove(0)
for (item in myList) println(item)

Here is the output from this example:

1
2
20
4
5
6

All the changes that the code made are shown in the output, as expected. Even with this sort of list, you have limits on what you can do unless you create your code correctly at the outset. For example, myList.add("Hello") would fail with myList in this case. To make it possible to add a string, you'd need to declare myList like this:

val myList: MutableList<Any> = mutableListOf(1, 2, 3, 4, 5)

Notice that the myList is now defined as being of type MutableList<Any>. As you work through your Android app, you have to choose the correct methods of interacting with app data to make your app secure, efficient, and fast. The collection choices that Kotlin provides let you make good choices more easily.