摘要：本章我们来学习一下的基本数据类型与类型系统。字符串就是一个抽象数据类型。如果程序语言的语法中含有类型标记，就称该语言是显式类型化的，否则就称为隐式类型化的。但是，可以把中对应的这几种基本数据类型，理解为的基本类型的装箱类。
第4章 基本数据类型与类型系统 《Kotlin极简教程》正式上架：
点击这里 > 去京东商城购买阅读 点击这里 > 去天猫商城购买阅读非常感谢您亲爱的读者，大家请多支持！！！有任何问题，欢迎随时与我交流~
到目前为止，我们已经了解了Kotlin的基本符号以及基础语法。我们可以看出，使用Kotlin写的代码更简洁、可读性更好、更富有生产力。
本章我们来学习一下Kotlin的基本数据类型与类型系统。
道生一，一生二，二生三，三生万物 (老子《道德经》第四十二章)
在计算机科学中，最早的类型系统用来区别数字里面的整数和浮点数。
在20世纪五六十年代，这种分类扩展到了结构化的数据和高阶函数中。
70年代，引入了几个更为丰富的概念，例如：参数化类型，抽象数据类型，模块系统，子类型等等，类型系统作为一个独立的领域形成了。
在每一门编程语言中，都有一个特定的类型系统(Type System)。类型系统是一门编程语言最核心也是最基础的部分。我们这里说的类型系统，可以简单理解为以下两个部分：
一组基本类型构成的PTS（Primary Type Set，基本类型集合）；
PTS上定义的一系列组合、运算、转换规则等。
这一简单优雅而惊人的世界构成观，贯穿了人类现实世界和计算机编程语言所定义的虚拟世界。或许语言的设计者也没有料想到，但是最终的结果确实是有限的设计导出了无限的可能性。
本章我们将学习Kotlin语言的基本类型，以及简单介绍Kotlin的类型系统。
4.1 什么是类型？一切皆是映射
在计算机中，任何数值都是以一组比特（01）组成的，硬件无法区分内存地址、脚本、字符、整数、以及浮点数。这个时候，我们使用类型赋予一组比特以特定的意义。
类型（Type），本质上就是内存中的数值或变量对象的逻辑映射。
《周易》有云：
易有太极，是生两仪，两仪生四象，四象生八卦。(《易传·系辞上传》) 。
这里所包含的思想，跟我们这里所说的类型系统的思想有着异曲同工之妙。
类型系统用于定义如何将编程语言中的数值和表达式归类为许多不同的类型，如何操作这些类型，这些类型如何互相作用等。
类型系统在各种语言之间有非常大的不同，主要的差异存在于编译时期的语法，以及运行时期的操作实现方式。
类型系统提供的主要功能有：
安全性
编译器可以使用类型来检查无意义的，或者是可能无效的代码。例如，在强类型的语言中，如果没有对字符串的+进行重载，那么表达式
"Hello, World" + 3
就会被编译器检测出来，因为不能对字符串加上一个整数。强类型提供更多的安全性。
但是，为了让程序员可以写出极简的代码，很多语言都提供了操作符重载的机制。比如说，在Scala中，上面的代码是可以被正确执行的（重载了+操作符）
scala> "Hello,World"+1 res15: String = Hello,World1 scala> 1+"Hello,World" res16: String = 1Hello,World
但是在Kotlin中， 由于Int类型没有对+实现重载，所以情况是这样
>>> "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" ^
最优化
静态类型检查可提供有用的信息给编译器。编译器可以使用更有效率的机器指令，实现编译器优化。
可读性
抽象化（或模块化）
类型本质上是对较低层次的逻辑单元进行高层次的逻辑抽象。这样我们就可以直接使用类型在较高层次的方式思考，而不是繁重的低层次实现。
例如，我们可以将字符串想成一个值，以此取代仅仅是字节的数组。字符串就是一个抽象数据类型。
从01到类型，从类型到接口API，再到软件服务，都可以看做是广义的“类型”范畴。
程序中的变量在程序执行期间，可能会有不同的取值范围，我们可以把变量可取值的最大范围称为这个变量的类型。例如，具有类型Boolean的变量x，在程序执行期间，只能取布尔值。指定变量类型的程序设计语言，称为类型化的语言（typed language）。
如果一个语言，不限制变量的取值，称为无类型语言（untyped language），我们既可以说它不具有类型，也可以说它具有一个通用类型，这个类型的取值范围是程序中所有可能的值。
类型系统是类型化语言的一个组成部分，它用来计算和跟踪程序中所有表达式的类型，从而判断某段程序是否表现良好（well behaved）。
如果程序语言的语法中含有类型标记，就称该语言是显式类型化的（explicitly typed），否则就称为隐式类型化的（implicitly typed）。
像C、C++、Java等语言，都是显式类型化的。而像ML、Haskell、Groovy等可以省略类型声明，它们的类型系统会自动推断出程序的类型。
4.2 编译时类型与运行时类型4.2.1 弱类型（Weakly checked language）与强类型（Strongly checked language）Koltin是一门强类型的、静态类型、支持隐式类型的显式类型语言。
类型系统最主要的作用是，通过检查类型的运算和转换过程，来减少类型错误的发生。如果一个语言的编译器引入越多的类型检查的限制，就可以称这个语言的类型检查越强，反之越弱。根据类型检查的强弱，我们把编程语言分为
弱类型语言
强类型语言
弱类型语言在运行时会隐式做数据类型转换。
强类型语言在运行时会确保不会发生未经明确转换（显式调用）的类型转换。
但是另一方面，强和弱只是相对的。
Kotlin是强类型语言。
4.2.2 静态类型（Statically checked language）与动态类型（Dynamicallychecked language）
类型检查可发生在编译时期（静态检查）或运行时期（动态检查）。这样我们将编程语言分为
静态类型语言
动态类型语言
静态类型检查是基于编译器来分析源码本身来确保类型安全。静态类型检查能让很多bug在编码早期被捕捉到，并且它也能优化运行。因为如果编译器在编译时已经证明程序是类型安全的，就不用在运行时进行动态的类型检查，编译过后的代码会更优化，运行更快。
动态类型语言是在运行时期进行类型标记的检查，因为变量所约束的值，可经由运行路径获得不同的标记。关于动态类型，有个很形象的说法：
当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。——詹姆斯·惠特科姆·莱利（James Whitcomb Riley,1849-1916）
Kotlin是静态类型语言。
4.2.3 显式类型（Explicitly typed language）与隐式类型（Implicitly typed language）还有一种区分方法是，根据变量名是否需要显式给出类型的声明，来将语言分为
显式类型语言
隐式类型语言
前者需要在定义变量时显式给出变量的类型，而后者可以使用类型推论来确定变量的类型。
大多数静态类型语言，例如 Java、C/C++ 都是显式类型语言。但是有些则不是，如 Haskell、ML 等，它们可以基于变量的操作来推断其类型；
Scala 是静态类型语言，它使用类型推断功能来支持隐式类型。
Kotlin 跟Scala类似，它也使用类型推断支持隐式类型。但是，在一些场景下也需要显式声明变量的类型，所以我们可以说，同时也是显式类型。
4.3 根类型AnyKotlin 中所有类都有一个共同的超类 Any ，如果类声明时没有指定超类，则默认为 Any 。我们来看一段代码：
>>> val any = Any() >>> any java.lang.Object@2e377400 >>> any::class class kotlin.Any >>> any::class.java class java.lang.Object
也就是说，Any在运行时，其类型自动映射成java.lang.Object。我们知道，在Java中Object类是所有引用类型的父类。但是不包括基本类型：byte int long等，基本类型对应的包装类是引用类型，其父类是Object。而在Kotlin中，直接统一——所有类型都是引用类型，统一继承父类Any。
Any是Java的等价Object类。但是跟Java不同的是，Kotlin中语言内部的类型和用户定义类型之间，并没有像Java那样划清界限。它们是同一类型层次结构的一部分。
Any 只有 equals() 、 hashCode() 和 toString() 三个方法。其源码是
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 对象相等性
从Any的源码注释中，我们可以看到，判断两个对象是否相等，需要满足以下条件：
自反性：对于任何非空引用值x，x.equals（x）应返回true。
对称性：对于任何非空引用值x和y，x.equals（y）应返回true当且仅当y.equals（x）返回true。
传递性：对于任何非空引用值x，y，z，如果x.equals（y）返回true，y.equals（z）返回true，那么x.equals（z）应返回true
一致性：对于任何非空引用值x和y，多次调用x.equals（y）始终返回true或者始终返回false。
另外，在Kotlin中，操作符==会被编译器翻译成调用equals() 函数。
4.4 基本类型（Primitive Types）本节我们来探讨学习：Kotlin的基础类型：数字、字符、布尔和数组等。
我们知道Java的类型分成两种：一种是基本类型，一种是引用类型。它们的本质区别是：
基本类型是在堆栈处分配空间存“值”，而引用类型是在堆里面分配空间存“值”。
Java的基本类型有： byte、int、short、long、float、double、char、boolean，这些类都有对应的装箱类（引用类型）。
另外，void也可以算是一种特殊的基本类型，它也有一个装箱类Void（跟我们后文讲到的Unit、Nothing相关）。因为，Void是不能new出来的，也就是不能在堆里面分配空间存对应的值。所以，Void是一开始在堆栈处分配好空间。所以，将Void归成基本类型。
在Kotlin中，一切皆是对象。所有类型都是引用类型。没有类似Java中的基本类型。但是，可以把Kotlin中对应的这几种基本数据类型，理解为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的基本类型的类图结构如下图所示
4.4.1 数字（Number）类型Kotlin 提供了如下的内置类型来表示数字（与 Java 很相近）：
| 类型 | 宽度（Bit） |
|---|---|
| Double | 64 |
| Float | 32 |
| Long | 64 |
| Int | 32 |
| Short | 16 |
| Byte | 8 |
从上面的Kotlin的基本类型的类的结构图，我们可以看出这些内置的数据类型，都继承了Number和 Comparable类。例如，Byte类型的声明：
public class Byte private constructor() : Number(), Comparable{ ... }
Kotlin 的数字类型跟 Java基本相同。有一点不同的是，Kotlin对于数字没有隐式拓宽转换（如 Java 中 int 可以隐式转换为long)。
注意在 Kotlin 中字符Char不是数字。这些基本数据类型，会在运行时自动优化为Java的double、float、long、int、short、byte。
字面常量值（literal constant values）数值常量字面值有以下几种:
十进制: 123
Long 类型用大写 L 标记: 123L
十六进制: 0x0F
二进制: 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
同样的，当我们赋值超过变量的类型的取值范围时，编译器会直接抛错。
注意: 不支持八进制
Kotlin 同样支持浮点数的常规表示方法:
默认 double：123.5、123.5e10
Float 用 f 或者 F 标记: 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
我们也可以使用数字字面值中的下划线（自 1.1 起），使数字常量更易读：
>>> 1_000_000 1000000 >>> 1234_5678_9012_3456L 1234567890123456 >>> 0xFF_EC_DE_5E 4293713502 >>> 0b11010010_01101001_10010100_10010010 3530134674
在 Java 平台数字是物理存储为 JVM 的原生类型，除非我们需要一个可空的引用（如 Int?）或泛型。
后者情况下会把数字装箱。
由于不同的表示方式，值范围较小类型并不是较大类型的子类型，是不能隐式转换的。
代码示例：
>>> 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
^
这意味着在不进行显式转换的情况下我们不能把 Int 型值赋给一个 Long 变量。也不能把 Byte 型值赋给一个 Int 变量。
我们可以显式转换来拓宽数字
>>> val i: Int = b.toInt() // OK: 显式拓宽
每个数字类型都继承Number抽象类，其中定义了如下的转换函数:
toDouble(): Double toFloat(): Float toLong(): Long toInt(): Int toChar(): Char toShort(): Short toByte(): Byte
所以，在数字之间的转换，我们直接调用上面的这些转换函数即可。
运算符+重载缺乏隐式类型转换并不显著，因为类型会从上下文推断出来，而算术运算会有重载做适当转换，例如：
val l = 1L + 3 // Long + Int => Long
这个是通过运算符+重载实现的。我们可以在Long类的源代码中看到这个plus 运算符函数的定义：
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
也就是说， 编译器会把1L + 3 翻译成 1L.plus(3)，然后这个传入的参数类型必须是Byte、Short、Int、Long、Float、Double中的一种。例如，我们传入一个字符Char参数，编译器就会直接抛错：
>>> "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" ^运算
Kotlin支持数字运算的标准集，运算被定义为相应的类成员（但编译器会将函数调用优化为相应的指令）。
对于位运算，没有特殊字符来表示，而只可用中缀方式调用命名函数（infix fun），例如:
val x = (1 shl 2) and 0x000FF000
这是完整的位运算列表（只用于 Int 和 Long）：
shl(bits) – 有符号左移 (Java 的 <<)
shr(bits) – 有符号右移 (Java 的 >>)
ushr(bits) – 无符号右移 (Java 的 >>>)
and(bits) – 位与
or(bits) – 位或
xor(bits) – 位异或
inv() – 位非
4.4.2 Char: 字符(Character)类型与转义符（Escape character）字符用 Char 类型表示。它们不能直接当作数字
fun check(c: Char) {
if (c == 1) { // 错误：类型不兼容
// ……
}
}
字符字面值用 单引号 括起来: "1"。
特殊字符可以用反斜杠转义。
Kotlin支持如下转义字符：
` " $
编码其他字符要用 Unicode 转义序列语法，例如："uFF00"。
Char类的函数接口定义如下：
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 }
我们来用代码示例这些函数的使用：
如果两个字符相等：
>>> "a".compareTo("a")
0
如果两个字符不相等：
>>> "a".compareTo("b")
-1
>>> "a".compareTo("c")
-1
>>> "b".compareTo("a")
1
>>> "c".compareTo("a")
1
Char字符只重载了加上Int类型的数字的+运算符：
>>> "a"+1 b >>> "a"+1L error: the integer literal does not conform to the expected type Int "a"+1L
所以，当我们把一个Char类型值和不是Int类型的值相加，就报错了。
相减：
>>> "a"-1 ` >>> "c"-"a" 2
自增计算：
>>> 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的显式类型转换函数如下：
/** 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
例如，我们显式把字符转换为 Int 数字：
fun decimalDigitValue(c: Char): Int {
if (c !in "0".."9")
throw IllegalArgumentException("Out of range")
return c.toInt() - "0".toInt() // 显式转换为数字
}
测试代码：
>>> decimalDigitValue("a")
java.lang.IllegalArgumentException: Out of range
at Line24.decimalDigitValue(Unknown Source)
>>> decimalDigitValue("1")
1
4.4.3 Boolean: 布尔类型
Kotlin的布尔类型用 Boolean 类来表示，它有两个值：true 和 false。
>>> true::class class kotlin.Boolean >>> true::class.java boolean
对应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类的内置的布尔运算有：
! 逻辑非 not()
&& 短路逻辑与 and()
|| 短路逻辑或or()
xor 异或(相同false，不同true)
另外，Boolean还继承实现了Comparable的compareTo()函数。
代码示例：
>>> !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 类型表示。对应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
^
索引运算符 s[i]
字符串的元素——字符可以使用索引运算符 s[i]来访问。
>>> val s="abc" >>> s abc >>> s[0] a
当我们下标越界时，会抛越界错误：
>>> 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)
从出错信息，我们可以看出，索引运算符 s[i]会被翻译成java.lang.String.charAt(), 背后调用的是Java的String类。其调用的方法是：
public char charAt(int index) {
if ((index < 0) || (index >= value.length)) {
throw new StringIndexOutOfBoundsException(index);
}
return value[index];
}
for 循环迭代字符串
我们可以用 for 循环迭代字符串:
>>> for(c in "abc") { println(c) }
a
b
c
关于字符串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 }
类似的，字符串有一个length属性：
>>> "abc".length 3重载+操作符
字符串类重载了+操作符，作用对象可以是任何对象，包括空引用：
>>> "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)
字符串字面值
字符串的字面值，可以包含原生字符串可以包含换行和任意文本，也可以是带有转义字符（Escape Charactor）的转义字符串。
>>> val s = "Hello,World! " >>> s Hello,World! >>>
转义采用传统的反斜杠方式。
原生字符串 使用三个引号（"""）分界符括起来，内部没有转义并且可以包含换行和任何其他字符:
>>> val text = """
... for (c in "abc")
... print(c)
... """
>>> text
for (c in "foo")
print(c)
>>>
另外，在package kotlin.text下面的Indent.kt代码中，Kotlin还定义了String类的扩展函数：
fun String.trimMargin(marginPrefix: String = "|"): String fun String.trimIndent(): String
我们可以使用trimMargin()、trimIndent() 裁剪函数来去除前导空格。可以看出，trimMargin()函数默认使用 "|" 来作为边界字符：
>>> val text = """ ... |理论是你知道是这样，但它却不好用。 ... |实践是它很好用，但你不知道是为什么。 ... |程序员将理论和实践结合到一起： ... |既不好用，也不知道是为什么。 ... """ >>> text.trimMargin() 理论是你知道是这样，但它却不好用。 实践是它很好用，但你不知道是为什么。 程序员将理论和实践结合到一起： 既不好用，也不知道是为什么。
默认 | 用作边界前缀，但你可以选择其他字符并作为参数传入，比如 trimMargin(">")。
trimIndent()函数，则是把字符串行的左边空白对齐切割：
>>> val text="""
... Hello
... World!
... """
>>> text.trimIndent()
Hello
World!
>>> val text="""
... Hello,
... World!
... """
>>> text.trimIndent()
Hello,
World!
字符串模板
字符串可以包含模板表达式 ，即一些小段代码，会求值并把结果合并到字符串中。
模板表达式以美元符（$）开头，由一个简单的名字构成:
>>> val h=100 >>> val str = "A hundred is $h" >>> str A hundred is 100
或者用花括号扩起来的任意表达式:
>>> val s = "abc"
>>> val str = "$s.length is ${s.length}"
>>> str
abc.length is 3
原生字符串和转义字符串内部都支持模板。
>>> 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: 数组类型
数组在 Kotlin 中使用 Array 类来表示，它定义了 get 和 set 函数（映射到重载运算符 []）和 size 属性，以及一个用于变量数组的iterator()函数：
class Arrayprivate constructor() { val size: Int operator fun get(index: Int): T operator fun set(index: Int, value: T): Unit operator fun iterator(): Iterator // …… }
我们可以使用函数 arrayOf() 来创建一个数组并传递元素值给它。这个函数签名如下：
public inline funarrayOf(vararg elements: T): Array
其中，vararg表示是一个参数个数是一个变量。
例如， arrayOf(1, 2, 3) 创建了 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还允许不同类型元素放到一个数组中，例如：
>>> 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自动把这个数组元素的类型升级为java.lang.Object， 同时，由于Kotlin拥有的类型推断的功能，我们仍然可以看到每个数组元素对应的各自的类型。
函数 arrayOfNulls() 可以用于创建一个指定大小、元素都为空的数组。这个特殊的空数组在创建的时候，我们需要指定元素的类型。如果不指定，直接按照下面这样写，会报错：
