說明如何處理 nullable types 及 read-only collections，同時去掉了 java 的 raw types 與 first-class support for arrays
Nullability
kotlin 的 nullability 可避免 java 的 NullPointerException error。kotlin 將問題由 runtime 移到 compile time。
如果傳入的參數為 null，會發生 NullPointerException
/* Java */
int strLen(String s) {
return s.length();
}在 Kotlin 呼叫 strLen 時，就不允許傳入 null
>>> fun strLen(s: String) = s.length
>>> strLen(null)
error: null can not be a value of a non-null type String
strLen(null)如果在 String 後面加上 ?，就代表傳入的字串可以是 String 或是 null，但 compiler 會檢查該 method 是否可以使用 null
>>> fun strLenSafe(s: String?) = s.length()
error: only safe (?.) or non-null asserted (!!.) calls are allowed on a nullable receiver of type String?
fun strLenSafe(s: String?) = s.length()
^
error: expression 'length' of type 'Int' cannot be invoked as a function. The function 'invoke()' is not found
fun strLenSafe(s: String?) = s.length()最正確的方式，是以下這樣
fun strLenSafe(s: String?): Int =
if (s != null) s.length else 0
fun main(args: Array<String>) {
val x: String? = null
println(strLenSafe(x))
println(strLenSafe("abc"))
}java 的變數雖然宣告為 String，但該 value 會有兩種狀況：String 或是 null，除非多寫檢查 null 的程式碼，否則很容易發生問題。Kotlin 將 nullable 與 non-null type 區隔開，用以避免這樣的問題。
safe call operator ?.
s?.toUpperCase() 就等同於 if (s != null) s.toUpperCase() else null ，將 null check 及 method call 合併為一個 operation
fun printAllCaps(s: String?) {
// allCaps 可以是 null
val allCaps: String? = s?.toUpperCase()
println(allCaps)
}
fun main(args: Array<String>) {
printAllCaps("abc")
printAllCaps(null)
}employee.manager 可能是 null，managerName回傳的值，也可能是 null
class Employee(val name: String, val manager: Employee?)
fun managerName(employee: Employee): String? = employee.manager?.name
fun main(args: Array<String>) {
val ceo = Employee("Da Boss", null)
val developer = Employee("Bob Smith", ceo)
println(managerName(developer))
println(managerName(ceo))
}可連續使用 ?.
class Address(val streetAddress: String, val zipCode: Int,
val city: String, val country: String)
class Company(val name: String, val address: Address?)
class Person(val name: String, val company: Company?)
fun Person.countryName(): String {
// company?. address?. 都有可能是 null
val country = this.company?.address?.country
return if (country != null) country else "Unknown"
}
fun main(args: Array<String>) {
val person = Person("Dmitry", null)
println(person.countryName())
}Elvis operator ?:
以 default value 取代 null，Elvis operator 也稱為 null-coalescing operator
當 s?.length 是 null，就設定為 0
fun strLenSafe(s: String?): Int = s?.length ?: 0
fun main(args: Array<String>) {
println(strLenSafe("abc"))
println(strLenSafe(null))
}Safe casts as?
java 的 as 可能會產生 ClassCastException。
Kotlin 提供 as? 語法，會嘗試轉換資料型別，發生問題就回傳 null
物件中的 equals method，因為參數是 Any? 任何一種資料型別都可傳入，因此在一開始，就用 as? 嘗試轉換資料型別，再進行欄位檢查。
class Person(val firstName: String, val lastName: String) {
override fun equals(o: Any?): Boolean {
val otherPerson = o as? Person ?: return false
return otherPerson.firstName == firstName &&
otherPerson.lastName == lastName
}
override fun hashCode(): Int =
firstName.hashCode() * 37 + lastName.hashCode()
}
fun main(args: Array<String>) {
val p1 = Person("Dmitry", "Jemerov")
val p2 = Person("Dmitry", "Jemerov")
println(p1 == p2)
println(p1.equals(42))
}Not-null assertions !!
!! 確認是否為 null，如果是 null 就會 throw kotlin.KotlinNullPointerException
fun ignoreNulls(s: String?) {
val sNotNull: String = s!!
println(sNotNull.length)
}
fun main(args: Array<String>) {
ignoreNulls(null)
}執行後會得到 Exception in thread "main" kotlin.KotlinNullPointerException
實務上的例子 CopyRowAction 會複製某一行的資料到 clipboard，isEnabled 用 list.selectedValue 是否為 null 進行檢查，確保
class CopyRowAction(val list: JList<String>) : AbstractAction() {
override fun isEnabled(): Boolean = list.selectedValue != null
override fun actionPerformed(e: ActionEvent) {
val value = list.selectedValue!!
// val value = list.selectedValue ?: return
// copy value to clipboard
}
}因為 !! 會產生 exception，所以不要寫這樣的 code
person.company!!.address!!.countrylet
用來處理要傳入某個需要 non-null 參數的 function，但是卻遇到 nullable argument。
用 let 搭配 lambda email?.let { sendEmailTo(it) }，如果 email 是 null，就不會呼叫 lambda function，藉此避免因 null 呼叫 sendEmailTo 產生 exception
fun sendEmailTo(email: String) {
println("Sending email to $email")
}
fun main(args: Array<String>) {
var email: String? = "yole@example.com"
email?.let { sendEmailTo(it) }
email = null
email?.let { sendEmailTo(it) }
}late-initialized properties
有很多 framework 需要的功能，在 object instance 產生後，要呼叫某個 method，類似 Android 的 onCreate，或是 JUnit 的 @Before
但因為 constructor 不能產生 non-null property，但如果還是要有 null property，就將該 property 宣告為 ?= null，並在 @Before 初始化 myService
import org.junit.Before
import org.junit.Test
import org.junit.Assert
class MyService {
fun performAction(): String = "foo"
}
class MyTest {
private var myService: MyService? = null
@Before fun setUp() {
myService = MyService()
}
@Test fun testAction() {
Assert.assertEquals("foo",
myService!!.performAction())
}
}kotlin 提供 lateinit 語法，只能用在 `var 變數，如果在還沒初始化前，使用了該變數，會得到 exception
import org.junit.Before
import org.junit.Test
import org.junit.Assert
class MyService {
fun performAction(): String = "foo"
}
class MyTest {
private lateinit var myService: MyService
@Before fun setUp() {
myService = MyService()
}
@Test fun testAction() {
Assert.assertEquals("foo",
myService.performAction())
}
}extensions on nullable types
為 nullable types 定義 extension function
fun verifyUserInput(input: String?) {
if (input.isNullOrBlank()) {
println("Please fill in the required fields")
}
}
fun main(args: Array<String>) {
verifyUserInput(" ")
verifyUserInput(null)
}將 input 以 isEmpty, isBland, isEmptyOrNull, isNullOrBlank 進行檢查
Nullability of type parameters
kotlin 的 functions, classes 的 type parameters 都是 nullable，type parameter 可替換為任意一種 type 包含 nullable type。
t:T 可以為 null
fun <T> printHashCode(t: T) {
println(t?.hashCode())
}
fun main(args: Array<String>) {
printHashCode(null)
}nullability and java
某些 java code 裡面有 @Nullable annotation，kotlin 會使用這些設定。
Java 的 @Nullable + Type 就等於 Kotlin 的 Type?
Java 的 @NotNull + Type 就等於 Kotlin 的 Type
platform type: kotlin 沒有 nullability information 的 type，如果確定一定不是 null，可直接使用，否則就要用 null-safe operation ?
Java 的 Type 等於 Kotlin 的 Type? 或是 Type
Person.java
/* Java */
public class Person {
private final String name;
public Person(String name) {
this.name = name;
}
public String getName() {
return name;
}
}getName 可能會回傳 null
import ch06.Person
fun yellAtSafe(person: Person) {
println((person.name ?: "Anyone").toUpperCase() + "!!!")
}
fun main(args: Array<String>) {
yellAtSafe(Person(null))
}在 kotlin override java method 時，可自行決定 return type 為 nullable 或 non-null
/* Java */
interface StringProcessor {
void process(String value);
}以下兩種 kotlin 實作的方式都可以
class StringPrinter : StringProcessor {
override fun process(value: String) {
println(value)
}
}
class NullableStringPrinter : StringProcessor {
override fun process(value: String?) {
if (value != null) {
println(value)
}
}
}operators for safe operations
- safe call ?.
- Elvis operator ?:
- safe cast as?)
operator for unsafe dereference
- not-null assertion !!
let non-null check
Primitive and other basic types
Int, Boolean
kotlin 沒有區分 primitive types 及 wrapper types
coerceIn 可限制 value 為某個特定的範圍
fun showProgress(progress: Int) {
val percent = progress.coerceIn(0, 100)
println("We're ${percent}% done!")
}
fun main(args: Array<String>) {
showProgress(146)
}kotlin 會將 Int 編譯為 Java 的 int，除非是用在 collections。
- Integer types: Byte, Short, Int, Long
- Floating-point number types: float, Double
- character type: Char
- boolean type: Boolean
nullable primitive types: Int?, Boolean?
kotlin 的 nullable types 不能轉換為 java 的 primitive type，要轉成 wrapper type
data class Person(val name: String,
val age: Int? = null) {
fun isOlderThan(other: Person): Boolean? {
if (age == null || other.age == null)
return null
return age > other.age
}
}
fun main(args: Array<String>) {
println(Person("Sam", 35).isOlderThan(Person("Amy", 42)))
println(Person("Sam", 35).isOlderThan(Person("Jane")))
}Number conversions
kotlin 跟 java 有個重要的差異：處理 numeric conversion 的方法不同。kotlin不會自動轉換 number 的資料型別。
以下的 code 會造成 type mismatch error
val i = 1
val l: Long = ii 必須強制作型別轉換
val i = 1
val l: Long = i.toLong()除了 Boolean 以外，其他的資料型別有提供 toByte(), toShort(), toChar() 這些轉換的 function
Java 中 new Integer(42).equals(new Long(42)) 會 returns false
kotlin 並不支援 implicit conversion，因此以下這個 code 會 return false
val x = 1
x in listOf(1L, 2L, 3L)必須要將 x 強制轉換為 Long，才會 return true
val x = 1
x.toLong() in listOf(1L, 2L, 3L)在進行數字運算時，會自動進行型別轉換，這是因為 operator 有 overloaded 接受所有 numeric types
fun foo(l: Long) = println(l)
fun main(args: Array<String>) {
val b: Byte = 1
val l = b + 1L
foo(42)
}kotlin 也有提供 string 轉成 number 的 function: toInt, toByte, toBoolean
println("42".toInt())Any and Any?
類似 Java 的 Object 是所有類別的 root class，Any 是 Kotlin 所有 non-nullable 類別的 root class
Java 提供 autoboxing 功能，編譯器自動將基本數據類型值轉換成對應的 wrapper class 的物件，例如將 int 轉換為 Integer 對象，將 boolean 轉換 Boolean 對象。而 unboxing 則是反過來轉換。
kotlin 的 Any 也有 autoboxing 的功能
val answer: Any = 42所有 kotlin class 都有繼承自 Any 的 toString(), equals(), hashCode()，但是在 java.lang.Object 中定義的其他 method (ex: wait, notify) 則必須要將型別轉換成 java.lang.Object 才能使用。
Unit type: kotlin 的 "void"
Unit 等同 java 的 void
fun f(): Unit { ... }上面的例子中，Unit 可省略不寫
fun f() { ... }Unit 跟 void 的差異是，Unit 是一種類別，void 是 type argument。
interface Processor<T> {
fun process(): T
}
class NoResultProcessor : Processor<Unit> {
// process 會回傳 Unit，但省略不寫
override fun process() {
// do stuff
// 不需要寫 return Unit
}
}Nothing type: this function never returns
對於某些 function 來說，有可能完全不需要 return value
fun fail(message: String): Nothing {
throw IllegalStateException(message)
}Nothing 沒有任何 value，可用在 function return type 或是 type argument
這個例子中，fail 不會有任何 return value，只會 throw exception
val address = company.address ?: fail("No address")
println(address.city)Collections and arrays
nullability and collections
可以用 String.toIntOrNull 取代 readNumbers 裡面做的事情
mport java.util.ArrayList
import java.io.BufferedReader
import java.io.StringReader
fun readNumbers(reader: BufferedReader): List<Int?> {
// 產生 a list of nullable Int values
val result = ArrayList<Int?>()
for (line in reader.lineSequence()) {
// 可轉換為 Int 就放到 list，否則就放入 null
try {
val number = line.toInt()
result.add(number)
}
catch(e: NumberFormatException) {
result.add(null)
}
}
return result
}
fun addValidNumbers(numbers: List<Int?>) {
var sumOfValidNumbers = 0
var invalidNumbers = 0
// 讀取 list 裡面的 value，判斷是否為 null
for (number in numbers) {
if (number != null) {
sumOfValidNumbers += number
} else {
invalidNumbers++
}
}
println("Sum of valid numbers: $sumOfValidNumbers")
println("Invalid numbers: $invalidNumbers")
}
fun main(args: Array<String>) {
val reader = BufferedReader(StringReader("1\nabc\n42"))
val numbers = readNumbers(reader)
addValidNumbers(numbers)
}addValidNumbers 可以簡化為 numbers.filterNotNull() 這樣的寫法
fun addValidNumbers(numbers: List<Int?>) {
val validNumbers = numbers.filterNotNull()
println("Sum of valid numbers: ${validNumbers.sum()}")
println("Invalid numbers: ${numbers.size - validNumbers.size}")
}要注意 List<Int?> 與 List<Int>? 的差異，前面的 list 永遠不會是 null，但每個 value 可以是 null，後面的 list 本身可以是 null，但 value 都不能是 null
read-only and mutable collections
kotlin.Collection 介面 (有 size, iterator(), contains())，切割了存取 data in a collection 及 modifying data 的工作
如果需要修改 collection 的資料，要使用 kotlin.MutableColelction (有 add(), remove(), clear())
這就像區分 val, var 一樣
fun <T> copyElements(source: Collection<T>,
target: MutableCollection<T>) {
// loop all items, add to MutableCollection
for (item in source) {
target.add(item)
}
}
fun main(args: Array<String>) {
val source: Collection<Int> = arrayListOf(3, 5, 7)
val target: MutableCollection<Int> = arrayListOf(1)
copyElements(source, target)
println(target)
}read-only collection 並不一定永遠不會改變，如果有一個 read-only 及 一個 mutable collection 指到同一個 collection object，還是可以透過 mutable collection 修改內容。使用 read-only collection 同時資料被修改時，會發生 ConcurrentModificationException
Kotlin collections and Java
每一個 Java collection interface 都有兩種 Kotlin class，一個是 read-only，一個是 mutable
collection creation functions
| Collection type | Read-Only | Mutable |
|---|---|---|
| List | listOf() | arrayListOf() |
| Set | setOf() | hashSetOf(), linkedSetOf(), sortedSetOf() |
| Map | mapOf() | hadhMapOf(), linkedMapOf(), sortedMapOf() |
Java method 如使用 java.util.Collection 為參數，可傳入 kotlin 的 Collection 或是 MutableCollection，因為 Java 無法分辨 read-only, mutable collection，可修改 read-only collection。
使用 Collection 跟 Java 互動，必須要自己注意 read-only collection 的狀態
CollecitonUtils.java
import java.util.List;
/* Java */
// CollectionUtils.java
public class CollectionUtils {
public static List<String> uppercaseAll(List<String> items) {
for (int i = 0; i < items.size(); i++) {
items.set(i, items.get(i).toUpperCase());
}
return items;
}
}import CollectionUtils
// Kotlin
// collections.kt
// 宣告為 read-only list 參數
fun printInUppercase(list: List<String>) {
// 呼叫 Java method 修改 list
println(CollectionUtils.uppercaseAll(list))
// 列印修改後的 list
println(list.first())
}
fun main(args: Array<String>) {
val list = listOf("a", "b", "c")
printInUppercase(list)
}Collections as platform types
java code 定義的 type 在 kotlin 視為 platform types
當要在 kotlin 覆寫或實作 java method，且裡面包含 collection type時，必須要注意如何定義 kotlin 的參數
- collection 是否為 nullable
- elements 是否為 nullable
- 這個 method 是否會修改 collection
/* Java */
interface FileContentProcessor {
void processContents(File path, byte[] binaryContents, List<String> textContents);
}在 kotlin 實作此 interface，要注意以下的事情
- list 為 nullable，因有些檔案是 text 不是 binary
- elements in the list 為 non-null，因為 lines in a file are never null
- list 為 red-only，因沒有要修改內容
class FileIndexer : FileContentProcessor {
override fun processContents(path: File, binaryContents: ByteArray?, textContents: List<String>?) {
// ...
}
}另一個例子
Java interface
/* Java */
interface DataParser<T> {
void parseData(String input,
List<T> output,
List<String> errors);
}- List
為 non-null - elements in the list 為 nullable
- List
為 mutable
kotlin 實作
class PersonParser : DataParser<Person> {
override fun parseData(input:
String,
output: MutableList<Person>,
errors: MutableList<String?>) {
// ...
}
}Arrays of objects and primitive types
kotlin 的 array 是 class with a type parameter
fun main(args: Array<String>) {
for (i in args.indices) {
println("Argument $i is: ${args[i]}")
}
}產生 array 的方式
- arrayOf
- arrayOfNulls 可包含 null elements
- Array 用 size 及 lambda function 產生array
以下是 Array 的範例
fun main(args: Array<String>) {
val letters = Array<String>(26) { i -> ('a' + i).toString() }
println(letters.joinToString(""))
// abcdefghijklmnopqrstuvwxyz
}toTypeArray 是另一種產生 array 的方式，前面的 * 代表室 vararg 參數，將 collection 轉換為 array
fun main(args: Array<String>) {
val strings = listOf("a", "b", "c")
println("%s/%s/%s".format(*strings.toTypedArray()))
}kotlin 提供 IntArray, ByteArray, CharArray, BooleanArray 對應 java 的 int[], byte[], char[] 等等
用 size 及 lambda function 產生 array
fun main(args: Array<String>) {
// 產生 5 個 0 的 IntArray
val fiveZeros = IntArray(5)
val fiveZerosToo = intArrayOf(0, 0, 0, 0, 0)
// 用 size 及 lambda function 產生 array
val squares = IntArray(5) { i -> (i+1) * (i+1) }
println(squares.joinToString())
}改寫 for (i in args.indices)，使用 forEachIndexed
fun main(args: Array<String>) {
args.forEachIndexed { index, element ->
println("Argument $index is: $element")
}
}