資訊專欄INFORMATION COLUMN
摘要：本章我們來學(xué)習(xí)一下的基本數(shù)據(jù)類型與類型系統(tǒng)。字符串就是一個(gè)抽象數(shù)據(jù)類型。如果程序語言的語法中含有類型標(biāo)記，就稱該語言是顯式類型化的，否則就稱為隱式類型化的。但是，可以把中對(duì)應(yīng)的這幾種基本數(shù)據(jù)類型，理解為的基本類型的裝箱類。
第4章 基本數(shù)據(jù)類型與類型系統(tǒng) 《Kotlin極簡教程》正式上架：
點(diǎn)擊這里 > 去京東商城購買閱讀 點(diǎn)擊這里 > 去天貓商城購買閱讀非常感謝您親愛的讀者，大家請(qǐng)多支持?。?！有任何問題，歡迎隨時(shí)與我交流~
到目前為止，我們已經(jīng)了解了Kotlin的基本符號(hào)以及基礎(chǔ)語法。我們可以看出，使用Kotlin寫的代碼更簡潔、可讀性更好、更富有生產(chǎn)力。
本章我們來學(xué)習(xí)一下Kotlin的基本數(shù)據(jù)類型與類型系統(tǒng)。
道生一，一生二，二生三，三生萬物 (老子《道德經(jīng)》第四十二章)
在計(jì)算機(jī)科學(xué)中，最早的類型系統(tǒng)用來區(qū)別數(shù)字里面的整數(shù)和浮點(diǎn)數(shù)。
在20世紀(jì)五六十年代，這種分類擴(kuò)展到了結(jié)構(gòu)化的數(shù)據(jù)和高階函數(shù)中。
70年代，引入了幾個(gè)更為豐富的概念，例如：參數(shù)化類型，抽象數(shù)據(jù)類型，模塊系統(tǒng)，子類型等等，類型系統(tǒng)作為一個(gè)獨(dú)立的領(lǐng)域形成了。
在每一門編程語言中，都有一個(gè)特定的類型系統(tǒng)(Type System)。類型系統(tǒng)是一門編程語言最核心也是最基礎(chǔ)的部分。我們這里說的類型系統(tǒng)，可以簡單理解為以下兩個(gè)部分：
一組基本類型構(gòu)成的PTS（Primary Type Set，基本類型集合）；
PTS上定義的一系列組合、運(yùn)算、轉(zhuǎn)換規(guī)則等。
這一簡單優(yōu)雅而驚人的世界構(gòu)成觀，貫穿了人類現(xiàn)實(shí)世界和計(jì)算機(jī)編程語言所定義的虛擬世界。或許語言的設(shè)計(jì)者也沒有料想到，但是最終的結(jié)果確實(shí)是有限的設(shè)計(jì)導(dǎo)出了無限的可能性。
本章我們將學(xué)習(xí)Kotlin語言的基本類型，以及簡單介紹Kotlin的類型系統(tǒng)。
4.1 什么是類型？一切皆是映射
在計(jì)算機(jī)中，任何數(shù)值都是以一組比特（01）組成的，硬件無法區(qū)分內(nèi)存地址、腳本、字符、整數(shù)、以及浮點(diǎn)數(shù)。這個(gè)時(shí)候，我們使用類型賦予一組比特以特定的意義。
類型（Type），本質(zhì)上就是內(nèi)存中的數(shù)值或變量對(duì)象的邏輯映射。
《周易》有云：
易有太極，是生兩儀，兩儀生四象，四象生八卦。(《易傳·系辭上傳》) 。
這里所包含的思想，跟我們這里所說的類型系統(tǒng)的思想有著異曲同工之妙。
類型系統(tǒng)用于定義如何將編程語言中的數(shù)值和表達(dá)式歸類為許多不同的類型，如何操作這些類型，這些類型如何互相作用等。
類型系統(tǒng)在各種語言之間有非常大的不同，主要的差異存在于編譯時(shí)期的語法，以及運(yùn)行時(shí)期的操作實(shí)現(xiàn)方式。
類型系統(tǒng)提供的主要功能有：
安全性
編譯器可以使用類型來檢查無意義的，或者是可能無效的代碼。例如，在強(qiáng)類型的語言中，如果沒有對(duì)字符串的+進(jìn)行重載，那么表達(dá)式
"Hello, World" + 3
就會(huì)被編譯器檢測出來，因?yàn)椴荒軐?duì)字符串加上一個(gè)整數(shù)。強(qiáng)類型提供更多的安全性。
但是，為了讓程序員可以寫出極簡的代碼，很多語言都提供了操作符重載的機(jī)制。比如說，在Scala中，上面的代碼是可以被正確執(zhí)行的（重載了+操作符）
scala> "Hello,World"+1 res15: String = Hello,World1 scala> 1+"Hello,World" res16: String = 1Hello,World
但是在Kotlin中， 由于Int類型沒有對(duì)+實(shí)現(xiàn)重載，所以情況是這樣
>>> "Hello,World"+1 Hello,World1 >>> 1+"Hello,World" error: none of the following functions can be called with the arguments supplied: public final operator fun plus(other: Byte): Int defined in kotlin.Int public final operator fun plus(other: Double): Double defined in kotlin.Int public final operator fun plus(other: Float): Float defined in kotlin.Int public final operator fun plus(other: Int): Int defined in kotlin.Int public final operator fun plus(other: Long): Long defined in kotlin.Int public final operator fun plus(other: Short): Int defined in kotlin.Int 1+"Hello,World" ^
最優(yōu)化
靜態(tài)類型檢查可提供有用的信息給編譯器。編譯器可以使用更有效率的機(jī)器指令，實(shí)現(xiàn)編譯器優(yōu)化。
可讀性
抽象化（或模塊化）
類型本質(zhì)上是對(duì)較低層次的邏輯單元進(jìn)行高層次的邏輯抽象。這樣我們就可以直接使用類型在較高層次的方式思考，而不是繁重的低層次實(shí)現(xiàn)。
例如，我們可以將字符串想成一個(gè)值，以此取代僅僅是字節(jié)的數(shù)組。字符串就是一個(gè)抽象數(shù)據(jù)類型。
從01到類型，從類型到接口API，再到軟件服務(wù)，都可以看做是廣義的“類型”范疇。
程序中的變量在程序執(zhí)行期間，可能會(huì)有不同的取值范圍，我們可以把變量可取值的最大范圍稱為這個(gè)變量的類型。例如，具有類型Boolean的變量x，在程序執(zhí)行期間，只能取布爾值。指定變量類型的程序設(shè)計(jì)語言，稱為類型化的語言（typed language）。
如果一個(gè)語言，不限制變量的取值，稱為無類型語言（untyped language），我們既可以說它不具有類型，也可以說它具有一個(gè)通用類型，這個(gè)類型的取值范圍是程序中所有可能的值。
類型系統(tǒng)是類型化語言的一個(gè)組成部分，它用來計(jì)算和跟蹤程序中所有表達(dá)式的類型，從而判斷某段程序是否表現(xiàn)良好（well behaved）。
如果程序語言的語法中含有類型標(biāo)記，就稱該語言是顯式類型化的（explicitly typed），否則就稱為隱式類型化的（implicitly typed）。
像C、C++、Java等語言，都是顯式類型化的。而像ML、Haskell、Groovy等可以省略類型聲明，它們的類型系統(tǒng)會(huì)自動(dòng)推斷出程序的類型。
4.2 編譯時(shí)類型與運(yùn)行時(shí)類型4.2.1 弱類型（Weakly checked language）與強(qiáng)類型（Strongly checked language）Koltin是一門強(qiáng)類型的、靜態(tài)類型、支持隱式類型的顯式類型語言。
類型系統(tǒng)最主要的作用是，通過檢查類型的運(yùn)算和轉(zhuǎn)換過程，來減少類型錯(cuò)誤的發(fā)生。如果一個(gè)語言的編譯器引入越多的類型檢查的限制，就可以稱這個(gè)語言的類型檢查越強(qiáng)，反之越弱。根據(jù)類型檢查的強(qiáng)弱，我們把編程語言分為
弱類型語言
強(qiáng)類型語言
弱類型語言在運(yùn)行時(shí)會(huì)隱式做數(shù)據(jù)類型轉(zhuǎn)換。
強(qiáng)類型語言在運(yùn)行時(shí)會(huì)確保不會(huì)發(fā)生未經(jīng)明確轉(zhuǎn)換（顯式調(diào)用）的類型轉(zhuǎn)換。
但是另一方面，強(qiáng)和弱只是相對(duì)的。
Kotlin是強(qiáng)類型語言。
4.2.2 靜態(tài)類型（Statically checked language）與動(dòng)態(tài)類型（Dynamicallychecked language）
類型檢查可發(fā)生在編譯時(shí)期（靜態(tài)檢查）或運(yùn)行時(shí)期（動(dòng)態(tài)檢查）。這樣我們將編程語言分為
靜態(tài)類型語言
動(dòng)態(tài)類型語言
靜態(tài)類型檢查是基于編譯器來分析源碼本身來確保類型安全。靜態(tài)類型檢查能讓很多bug在編碼早期被捕捉到，并且它也能優(yōu)化運(yùn)行。因?yàn)槿绻幾g器在編譯時(shí)已經(jīng)證明程序是類型安全的，就不用在運(yùn)行時(shí)進(jìn)行動(dòng)態(tài)的類型檢查，編譯過后的代碼會(huì)更優(yōu)化，運(yùn)行更快。
動(dòng)態(tài)類型語言是在運(yùn)行時(shí)期進(jìn)行類型標(biāo)記的檢查，因?yàn)樽兞克s束的值，可經(jīng)由運(yùn)行路徑獲得不同的標(biāo)記。關(guān)于動(dòng)態(tài)類型，有個(gè)很形象的說法：
當(dāng)看到一只鳥走起來像鴨子、游泳起來像鴨子、叫起來也像鴨子，那么這只鳥就可以被稱為鴨子?！材匪埂せ萏乜颇贰とR利（James Whitcomb Riley,1849-1916）
Kotlin是靜態(tài)類型語言。
4.2.3 顯式類型（Explicitly typed language）與隱式類型（Implicitly typed language）還有一種區(qū)分方法是，根據(jù)變量名是否需要顯式給出類型的聲明，來將語言分為
顯式類型語言
隱式類型語言
前者需要在定義變量時(shí)顯式給出變量的類型，而后者可以使用類型推論來確定變量的類型。
大多數(shù)靜態(tài)類型語言，例如 Java、C/C++ 都是顯式類型語言。但是有些則不是，如 Haskell、ML 等，它們可以基于變量的操作來推斷其類型；
Scala 是靜態(tài)類型語言，它使用類型推斷功能來支持隱式類型。
Kotlin 跟Scala類似，它也使用類型推斷支持隱式類型。但是，在一些場景下也需要顯式聲明變量的類型，所以我們可以說，同時(shí)也是顯式類型。
4.3 根類型AnyKotlin 中所有類都有一個(gè)共同的超類 Any ，如果類聲明時(shí)沒有指定超類，則默認(rèn)為 Any 。我們來看一段代碼：
>>> val any = Any() >>> any java.lang.Object@2e377400 >>> any::class class kotlin.Any >>> any::class.java class java.lang.Object
也就是說，Any在運(yùn)行時(shí)，其類型自動(dòng)映射成java.lang.Object。我們知道，在Java中Object類是所有引用類型的父類。但是不包括基本類型：byte int long等，基本類型對(duì)應(yīng)的包裝類是引用類型，其父類是Object。而在Kotlin中，直接統(tǒng)一——所有類型都是引用類型，統(tǒng)一繼承父類Any。
Any是Java的等價(jià)Object類。但是跟Java不同的是，Kotlin中語言內(nèi)部的類型和用戶定義類型之間，并沒有像Java那樣劃清界限。它們是同一類型層次結(jié)構(gòu)的一部分。
Any 只有 equals() 、 hashCode() 和 toString() 三個(gè)方法。其源碼是
public open class Any {
/**
* Indicates whether some other object is "equal to" this one. Implementations must fulfil the following
* requirements:
*
* * Reflexive: for any non-null reference value x, x.equals(x) should return true.
* * Symmetric: for any non-null reference values x and y, x.equals(y) should return true if and only if y.equals(x) returns true.
* * Transitive: for any non-null reference values x, y, and z, if x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) should return true
* * Consistent: for any non-null reference values x and y, multiple invocations of x.equals(y) consistently return true or consistently return false, provided no information used in equals comparisons on the objects is modified.
*
* Note that the `==` operator in Kotlin code is translated into a call to [equals] when objects on both sides of the
* operator are not null.
*/
public open operator fun equals(other: Any?): Boolean
/**
* Returns a hash code value for the object. The general contract of hashCode is:
*
* * Whenever it is invoked on the same object more than once, the hashCode method must consistently return the same integer, provided no information used in equals comparisons on the object is modified.
* * If two objects are equal according to the equals() method, then calling the hashCode method on each of the two objects must produce the same integer result.
*/
public open fun hashCode(): Int
/**
* Returns a string representation of the object.
*/
public open fun toString(): String
}
4.3.1 對(duì)象相等性
從Any的源碼注釋中，我們可以看到，判斷兩個(gè)對(duì)象是否相等，需要滿足以下條件：
自反性：對(duì)于任何非空引用值x，x.equals（x）應(yīng)返回true。
對(duì)稱性：對(duì)于任何非空引用值x和y，x.equals（y）應(yīng)返回true當(dāng)且僅當(dāng)y.equals（x）返回true。
傳遞性：對(duì)于任何非空引用值x，y，z，如果x.equals（y）返回true，y.equals（z）返回true，那么x.equals（z）應(yīng)返回true
一致性：對(duì)于任何非空引用值x和y，多次調(diào)用x.equals（y）始終返回true或者始終返回false。
另外，在Kotlin中，操作符==會(huì)被編譯器翻譯成調(diào)用equals() 函數(shù)。
4.4 基本類型（Primitive Types）本節(jié)我們來探討學(xué)習(xí)：Kotlin的基礎(chǔ)類型：數(shù)字、字符、布爾和數(shù)組等。
我們知道Java的類型分成兩種：一種是基本類型，一種是引用類型。它們的本質(zhì)區(qū)別是：
基本類型是在堆棧處分配空間存“值”，而引用類型是在堆里面分配空間存“值”。
Java的基本類型有： byte、int、short、long、float、double、char、boolean，這些類都有對(duì)應(yīng)的裝箱類（引用類型）。
另外，void也可以算是一種特殊的基本類型，它也有一個(gè)裝箱類Void（跟我們后文講到的Unit、Nothing相關(guān)）。因?yàn)?，Void是不能new出來的，也就是不能在堆里面分配空間存對(duì)應(yīng)的值。所以，Void是一開始在堆棧處分配好空間。所以，將Void歸成基本類型。
在Kotlin中，一切皆是對(duì)象。所有類型都是引用類型。沒有類似Java中的基本類型。但是，可以把Kotlin中對(duì)應(yīng)的這幾種基本數(shù)據(jù)類型，理解為Java的基本類型的裝箱類。
Integer.java
public final class Integer extends Number implements Comparable{ /** * A constant holding the minimum value an {@code int} can * have, -231. */ @Native public static final int MIN_VALUE = 0x80000000; /** * A constant holding the maximum value an {@code int} can * have, 231-1. */ @Native public static final int MAX_VALUE = 0x7fffffff; /** * The {@code Class} instance representing the primitive type * {@code int}. * * @since JDK1.1 */ @SuppressWarnings("unchecked") public static final Class TYPE = (Class ) Class.getPrimitiveClass("int"); ... }
Kotlin中的Int類型：
public class Int private constructor() : Number(), Comparable{ companion object { /** * A constant holding the minimum value an instance of Int can have. */ public const val MIN_VALUE: Int = -2147483648 /** * A constant holding the maximum value an instance of Int can have. */ public const val MAX_VALUE: Int = 2147483647 } ... }
我們通過Java的Integer封裝類，跟Kotlin的Int類的定義可以看出兩者的思想上的同源性。
Kotlin的基本類型的類圖結(jié)構(gòu)如下圖所示
4.4.1 數(shù)字（Number）類型Kotlin 提供了如下的內(nèi)置類型來表示數(shù)字（與 Java 很相近）：
| 類型 | 寬度（Bit） |
|---|---|
| Double | 64 |
| Float | 32 |
| Long | 64 |
| Int | 32 |
| Short | 16 |
| Byte | 8 |
從上面的Kotlin的基本類型的類的結(jié)構(gòu)圖，我們可以看出這些內(nèi)置的數(shù)據(jù)類型，都繼承了Number和 Comparable類。例如，Byte類型的聲明：
public class Byte private constructor() : Number(), Comparable{ ... }
Kotlin 的數(shù)字類型跟 Java基本相同。有一點(diǎn)不同的是，Kotlin對(duì)于數(shù)字沒有隱式拓寬轉(zhuǎn)換（如 Java 中 int 可以隱式轉(zhuǎn)換為long)。
注意在 Kotlin 中字符Char不是數(shù)字。這些基本數(shù)據(jù)類型，會(huì)在運(yùn)行時(shí)自動(dòng)優(yōu)化為Java的double、float、long、int、short、byte。
字面常量值（literal constant values）數(shù)值常量字面值有以下幾種:
十進(jìn)制: 123
Long 類型用大寫 L 標(biāo)記: 123L
十六進(jìn)制: 0x0F
二進(jìn)制: 0b00001011
代碼示例：
>>> 123
123
>>> 123::class
class kotlin.Int
>>> 123::class.java
int
>>> 123L
123
>>> 123L::class
class kotlin.Long
>>> 123L::class.java
long
>>> val b:Byte=128
error: the integer literal does not conform to the expected type Byte
val b:Byte=128
^
>>> val b:Byte=127
>>> b::class
class kotlin.Byte
>>> b::class.java
byte
>>> 0x0f
15
>>> 0x0F
15
>>> 0b1000
8
同樣的，當(dāng)我們賦值超過變量的類型的取值范圍時(shí)，編譯器會(huì)直接拋錯(cuò)。
注意: 不支持八進(jìn)制
Kotlin 同樣支持浮點(diǎn)數(shù)的常規(guī)表示方法:
默認(rèn) double：123.5、123.5e10
Float 用 f 或者 F 標(biāo)記: 123.5f
代碼示例：
>>> 1234.5 1234.5 >>> 1234.5::class class kotlin.Double >>> 1234.5::class.java double >>> 12.3e10 1.23E11 >>> 12.3e10::class class kotlin.Double >>> 456.7f 456.7 >>> 456.7f::class class kotlin.Float >>> 456.7f::class.java float
我們也可以使用數(shù)字字面值中的下劃線（自 1.1 起），使數(shù)字常量更易讀：
>>> 1_000_000 1000000 >>> 1234_5678_9012_3456L 1234567890123456 >>> 0xFF_EC_DE_5E 4293713502 >>> 0b11010010_01101001_10010100_10010010 3530134674
在 Java 平臺(tái)數(shù)字是物理存儲(chǔ)為 JVM 的原生類型，除非我們需要一個(gè)可空的引用（如 Int?）或泛型。
后者情況下會(huì)把數(shù)字裝箱。
由于不同的表示方式，值范圍較小類型并不是較大類型的子類型，是不能隱式轉(zhuǎn)換的。
代碼示例：
>>> val a: Int? = 1
>>> val b: Long? = a
error: type mismatch: inferred type is Int? but Long? was expected
val b: Long? = a
^
>>> val b: Byte = 1
>>> val i: Int = b
error: type mismatch: inferred type is Byte but Int was expected
val i: Int = b
^
這意味著在不進(jìn)行顯式轉(zhuǎn)換的情況下我們不能把 Int 型值賦給一個(gè) Long 變量。也不能把 Byte 型值賦給一個(gè) Int 變量。
我們可以顯式轉(zhuǎn)換來拓寬數(shù)字
>>> val i: Int = b.toInt() // OK: 顯式拓寬
每個(gè)數(shù)字類型都繼承Number抽象類，其中定義了如下的轉(zhuǎn)換函數(shù):
toDouble(): Double toFloat(): Float toLong(): Long toInt(): Int toChar(): Char toShort(): Short toByte(): Byte
所以，在數(shù)字之間的轉(zhuǎn)換，我們直接調(diào)用上面的這些轉(zhuǎn)換函數(shù)即可。
運(yùn)算符+重載缺乏隱式類型轉(zhuǎn)換并不顯著，因?yàn)轭愋蜁?huì)從上下文推斷出來，而算術(shù)運(yùn)算會(huì)有重載做適當(dāng)轉(zhuǎn)換，例如：
val l = 1L + 3 // Long + Int => Long
這個(gè)是通過運(yùn)算符+重載實(shí)現(xiàn)的。我們可以在Long類的源代碼中看到這個(gè)plus 運(yùn)算符函數(shù)的定義：
public operator fun plus(other: Byte): Long
public operator fun plus(other: Short): Long
public operator fun plus(other: Int): Long
public operator fun plus(other: Long): Long
public operator fun plus(other: Float): Float
public operator fun plus(other: Double): Double
也就是說， 編譯器會(huì)把1L + 3 翻譯成 1L.plus(3)，然后這個(gè)傳入的參數(shù)類型必須是Byte、Short、Int、Long、Float、Double中的一種。例如，我們傳入一個(gè)字符Char參數(shù)，編譯器就會(huì)直接拋錯(cuò)：
>>> "a" a >>> "a"::class class kotlin.Char >>> "a"::class.java char >>> 1L+"a" error: none of the following functions can be called with the arguments supplied: public final operator fun plus(other: Byte): Long defined in kotlin.Long public final operator fun plus(other: Double): Double defined in kotlin.Long public final operator fun plus(other: Float): Float defined in kotlin.Long public final operator fun plus(other: Int): Long defined in kotlin.Long public final operator fun plus(other: Long): Long defined in kotlin.Long public final operator fun plus(other: Short): Long defined in kotlin.Long 1L+"a" ^運(yùn)算
Kotlin支持?jǐn)?shù)字運(yùn)算的標(biāo)準(zhǔn)集，運(yùn)算被定義為相應(yīng)的類成員（但編譯器會(huì)將函數(shù)調(diào)用優(yōu)化為相應(yīng)的指令）。
對(duì)于位運(yùn)算，沒有特殊字符來表示，而只可用中綴方式調(diào)用命名函數(shù)（infix fun），例如:
val x = (1 shl 2) and 0x000FF000
這是完整的位運(yùn)算列表（只用于 Int 和 Long）：
shl(bits) – 有符號(hào)左移 (Java 的 <<)
shr(bits) – 有符號(hào)右移 (Java 的 >>)
ushr(bits) – 無符號(hào)右移 (Java 的 >>>)
and(bits) – 位與
or(bits) – 位或
xor(bits) – 位異或
inv() – 位非
4.4.2 Char: 字符(Character)類型與轉(zhuǎn)義符（Escape character）字符用 Char 類型表示。它們不能直接當(dāng)作數(shù)字
fun check(c: Char) {
if (c == 1) { // 錯(cuò)誤：類型不兼容
// ……
}
}
字符字面值用 單引號(hào) 括起來: "1"。
特殊字符可以用反斜杠轉(zhuǎn)義。
Kotlin支持如下轉(zhuǎn)義字符：
` " $
編碼其他字符要用 Unicode 轉(zhuǎn)義序列語法，例如："uFF00"。
Char類的函數(shù)接口定義如下：
public class Char private constructor() : Comparable{ /** * Compares this value with the specified value for order. * Returns zero if this value is equal to the specified other value, a negative number if it"s less than other, * or a positive number if it"s greater than other. */ public override fun compareTo(other: Char): Int /** Adds the other Int value to this value resulting a Char. */ public operator fun plus(other: Int): Char /** Subtracts the other Char value from this value resulting an Int. */ public operator fun minus(other: Char): Int /** Subtracts the other Int value from this value resulting a Char. */ public operator fun minus(other: Int): Char /** Increments this value. */ public operator fun inc(): Char /** Decrements this value. */ public operator fun dec(): Char /** Creates a range from this value to the specified [other] value. */ public operator fun rangeTo(other: Char): CharRange /** Returns the value of this character as a `Byte`. */ public fun toByte(): Byte /** Returns the value of this character as a `Char`. */ public fun toChar(): Char /** Returns the value of this character as a `Short`. */ public fun toShort(): Short /** Returns the value of this character as a `Int`. */ public fun toInt(): Int /** Returns the value of this character as a `Long`. */ public fun toLong(): Long /** Returns the value of this character as a `Float`. */ public fun toFloat(): Float /** Returns the value of this character as a `Double`. */ public fun toDouble(): Double }
我們來用代碼示例這些函數(shù)的使用：
如果兩個(gè)字符相等：
>>> "a".compareTo("a")
0
如果兩個(gè)字符不相等：
>>> "a".compareTo("b")
-1
>>> "a".compareTo("c")
-1
>>> "b".compareTo("a")
1
>>> "c".compareTo("a")
1
Char字符只重載了加上Int類型的數(shù)字的+運(yùn)算符：
>>> "a"+1 b >>> "a"+1L error: the integer literal does not conform to the expected type Int "a"+1L
所以，當(dāng)我們把一個(gè)Char類型值和不是Int類型的值相加，就報(bào)錯(cuò)了。
相減：
>>> "a"-1 ` >>> "c"-"a" 2
自增計(jì)算：
>>> var a="a" >>> val b=a++ >>> a b >>> b a >>> val c=++a >>> c c
我們不能在字符的字面量上直接使用++:
>>> "a"++ error: variable expected "a"++ ^ >>> ++"a" error: variable expected ++"a" ^
范圍
>>> "a".rangeTo("z")
a..z
>>> for(c in "a".."z") {print(c)}
abcdefghijklmnopqrstuvwxyz
Char的顯式類型轉(zhuǎn)換函數(shù)如下：
/** Returns the value of this character as a `Byte`. */
public fun toByte(): Byte
/** Returns the value of this character as a `Char`. */
public fun toChar(): Char
/** Returns the value of this character as a `Short`. */
public fun toShort(): Short
/** Returns the value of this character as a `Int`. */
public fun toInt(): Int
/** Returns the value of this character as a `Long`. */
public fun toLong(): Long
/** Returns the value of this character as a `Float`. */
public fun toFloat(): Float
/** Returns the value of this character as a `Double`. */
public fun toDouble(): Double
例如，我們顯式把字符轉(zhuǎn)換為 Int 數(shù)字：
fun decimalDigitValue(c: Char): Int {
if (c !in "0".."9")
throw IllegalArgumentException("Out of range")
return c.toInt() - "0".toInt() // 顯式轉(zhuǎn)換為數(shù)字
}
測試代碼：
>>> decimalDigitValue("a")
java.lang.IllegalArgumentException: Out of range
at Line24.decimalDigitValue(Unknown Source)
>>> decimalDigitValue("1")
1
4.4.3 Boolean: 布爾類型
Kotlin的布爾類型用 Boolean 類來表示，它有兩個(gè)值：true 和 false。
>>> true::class class kotlin.Boolean >>> true::class.java boolean
對(duì)應(yīng)Java中的boolean類型。
其源碼定義如下：
package kotlin /** * Represents a value which is either `true` or `false`. On the JVM, non-nullable values of this type are * represented as values of the primitive type `boolean`. */ public class Boolean private constructor() : Comparable{ /** * Returns the inverse of this boolean. */ public operator fun not(): Boolean /** * Performs a logical `and` operation between this Boolean and the [other] one. */ public infix fun and(other: Boolean): Boolean /** * Performs a logical `or` operation between this Boolean and the [other] one. */ public infix fun or(other: Boolean): Boolean /** * Performs a logical `xor` operation between this Boolean and the [other] one. */ public infix fun xor(other: Boolean): Boolean public override fun compareTo(other: Boolean): Int }
從上面我們可以看出，Boolean類的內(nèi)置的布爾運(yùn)算有：
! 邏輯非 not()
&& 短路邏輯與 and()
|| 短路邏輯或or()
xor 異或(相同false，不同true)
另外，Boolean還繼承實(shí)現(xiàn)了Comparable的compareTo()函數(shù)。
代碼示例：
>>> !true false >>> true.not() false >>> true && true true >>> true.and(false) false >>> true || false true >>> false.or(false) false >>> true xor true false >>> true xor false true >>> false xor false false >>> true > false true >>> true < false false >>> true.compareTo(false) 1 >>> true.compareTo(false) 1 >>> true.compareTo(true) 0 >>> false.compareTo(true) -14.4.4 String: 字符串類型
Kotlin的字符串用 String 類型表示。對(duì)應(yīng)Java中的java.lang.String。字符串是不可變的。
>>> "abc"::class class kotlin.String >>> "abc"::class.java class java.lang.String
另外，在Kotlin中，String同樣是final不可繼承的。
代碼示例：
>>> class MyString:String
error: this type is final, so it cannot be inherited from
class MyString:String
^
索引運(yùn)算符 s[i]
字符串的元素——字符可以使用索引運(yùn)算符 s[i]來訪問。
>>> val s="abc" >>> s abc >>> s[0] a
當(dāng)我們下標(biāo)越界時(shí)，會(huì)拋越界錯(cuò)誤：
>>> s[-1]
java.lang.StringIndexOutOfBoundsException: String index out of range: -1
at java.lang.String.charAt(String.java:646)
>>> s[3]
java.lang.StringIndexOutOfBoundsException: String index out of range: 3
at java.lang.String.charAt(String.java:646)
從出錯(cuò)信息，我們可以看出，索引運(yùn)算符 s[i]會(huì)被翻譯成java.lang.String.charAt(), 背后調(diào)用的是Java的String類。其調(diào)用的方法是：
public char charAt(int index) {
if ((index < 0) || (index >= value.length)) {
throw new StringIndexOutOfBoundsException(index);
}
return value[index];
}
for 循環(huán)迭代字符串
我們可以用 for 循環(huán)迭代字符串:
>>> for(c in "abc") { println(c) }
a
b
c
關(guān)于字符串String類的完整的操作方法，我們可以看下源碼：
public class String : Comparable, CharSequence { companion object {} /** * Returns a string obtained by concatenating this string with the string representation of the given [other] object. */ public operator fun plus(other: Any?): String public override val length: Int public override fun get(index: Int): Char public override fun subSequence(startIndex: Int, endIndex: Int): CharSequence public override fun compareTo(other: String): Int }
類似的，字符串有一個(gè)length屬性：
>>> "abc".length 3重載+操作符
字符串類重載了+操作符，作用對(duì)象可以是任何對(duì)象，包括空引用：
>>> "abc".plus(true) abctrue >>> "abc"+false abcfalse >>> "abc"+1 abc1 >>> "abc"+1.20 abc1.2 >>> "abc"+100L abc100 >>> "abc"+"cdef" abccdef >>> "abc"+null abcnull >>> "abc"+"z" abcz >>> "abc"+arrayOf(1,2,3,4,5) abc[Ljava.lang.Integer;@3d6f0054
截取字符串的子串：
>>> "abc".subSequence(0,1)
a
>>> "abc".subSequence(0,2)
ab
>>> "abc".subSequence(0,3)
abc
>>> "abc".subSequence(0,4)
java.lang.StringIndexOutOfBoundsException: String index out of range: 4
at java.lang.String.substring(String.java:1951)
at java.lang.String.subSequence(String.java:1991)
字符串字面值
字符串的字面值，可以包含原生字符串可以包含換行和任意文本，也可以是帶有轉(zhuǎn)義字符（Escape Charactor）的轉(zhuǎn)義字符串。
>>> val s = "Hello,World! " >>> s Hello,World! >>>
轉(zhuǎn)義采用傳統(tǒng)的反斜杠方式。
原生字符串 使用三個(gè)引號(hào)（"""）分界符括起來，內(nèi)部沒有轉(zhuǎn)義并且可以包含換行和任何其他字符:
>>> val text = """
... for (c in "abc")
... print(c)
... """
>>> text
for (c in "foo")
print(c)
>>>
另外，在package kotlin.text下面的Indent.kt代碼中，Kotlin還定義了String類的擴(kuò)展函數(shù)：
fun String.trimMargin(marginPrefix: String = "|"): String fun String.trimIndent(): String
我們可以使用trimMargin()、trimIndent() 裁剪函數(shù)來去除前導(dǎo)空格。可以看出，trimMargin()函數(shù)默認(rèn)使用 "|" 來作為邊界字符：
>>> val text = """ ... |理論是你知道是這樣，但它卻不好用。 ... |實(shí)踐是它很好用，但你不知道是為什么。 ... |程序員將理論和實(shí)踐結(jié)合到一起： ... |既不好用，也不知道是為什么。 ... """ >>> text.trimMargin() 理論是你知道是這樣，但它卻不好用。 實(shí)踐是它很好用，但你不知道是為什么。 程序員將理論和實(shí)踐結(jié)合到一起： 既不好用，也不知道是為什么。
默認(rèn) | 用作邊界前綴，但你可以選擇其他字符并作為參數(shù)傳入，比如 trimMargin(">")。
trimIndent()函數(shù)，則是把字符串行的左邊空白對(duì)齊切割：
>>> val text="""
... Hello
... World!
... """
>>> text.trimIndent()
Hello
World!
>>> val text="""
... Hello,
... World!
... """
>>> text.trimIndent()
Hello,
World!
字符串模板
字符串可以包含模板表達(dá)式 ，即一些小段代碼，會(huì)求值并把結(jié)果合并到字符串中。
模板表達(dá)式以美元符（$）開頭，由一個(gè)簡單的名字構(gòu)成:
>>> val h=100 >>> val str = "A hundred is $h" >>> str A hundred is 100
或者用花括號(hào)擴(kuò)起來的任意表達(dá)式:
>>> val s = "abc"
>>> val str = "$s.length is ${s.length}"
>>> str
abc.length is 3
原生字符串和轉(zhuǎn)義字符串內(nèi)部都支持模板。
>>> val price=9.9 >>> val str="""Price is $$price""" >>> str Price is $9.9 >>> val str="Price is $$price" >>> str Price is $9.9 >>> val quantity=100 >>> val str="Quantity is $quantity" >>> str Quantity is 100 >>> val str="""Quantity is $quantity""" >>> str Quantity is 1004.4.5 Array: 數(shù)組類型
數(shù)組在 Kotlin 中使用 Array 類來表示，它定義了 get 和 set 函數(shù)（映射到重載運(yùn)算符 []）和 size 屬性，以及一個(gè)用于變量數(shù)組的iterator()函數(shù)：
class Arrayprivate constructor() { val size: Int operator fun get(index: Int): T operator fun set(index: Int, value: T): Unit operator fun iterator(): Iterator // …… }
我們可以使用函數(shù) arrayOf() 來創(chuàng)建一個(gè)數(shù)組并傳遞元素值給它。這個(gè)函數(shù)簽名如下：
public inline funarrayOf(vararg elements: T): Array
其中，vararg表示是一個(gè)參數(shù)個(gè)數(shù)是一個(gè)變量。
例如， arrayOf(1, 2, 3) 創(chuàng)建了 array [1, 2, 3] :
>>> arrayOf(1,2,3) [Ljava.lang.Integer;@4a37191a >>> arrayOf(1,2,3)::class class kotlin.Array >>> arrayOf(1,2,3)::class.java class [Ljava.lang.Integer;
另外，Kotlin還允許不同類型元素放到一個(gè)數(shù)組中，例如：
>>> val arr = arrayOf(1,"2",true)
>>> arr
[Ljava.lang.Object;@61af1510
>>> arr.forEach{ println(it) }
1
2
true
>>> arr.forEach{ println(it::class) }
class kotlin.Int
class kotlin.String
class kotlin.Boolean
Kotlin自動(dòng)把這個(gè)數(shù)組元素的類型升級(jí)為java.lang.Object， 同時(shí)，由于Kotlin擁有的類型推斷的功能，我們?nèi)匀豢梢钥吹矫總€(gè)數(shù)組元素對(duì)應(yīng)的各自的類型。
函數(shù) arrayOfNulls() 可以用于創(chuàng)建一個(gè)指定大小、元素都為空的數(shù)組。這個(gè)特殊的空數(shù)組在創(chuàng)建的時(shí)候，我們需要指定元素的類型。如果不指定，直接按照下面這樣寫，會(huì)報(bào)錯(cuò)：
