Kotlin基础知识一

1. Kotlin 基本数据类型

Kotlin 的基本数值类型： Byte、Short、Int、Long、Float、Double 等。
不同于Java的是，字符不属于数值类型，是一个独立的数据类型。

类型 位宽度 Double 64 Float 32 Long 64 Int 32 Short 16 Byte 8

---

2.字面常量

十进制：123
长整型以大写的 L 结尾：123L
2 进制以 0b 开头：0b00001011
16 进制以 0x 开头：0x0F
注意：8进制不支持

Kotlin 同时也支持传统符号表示的浮点数值：
Doubles 默认写法: 123.5, 123.5e10
Floats 使用 f 或者 F 后缀：123.5f

可以使用下划线使数字常量更易读：
val creditCardNumber = 1234_5678_9012_3456L
val socialSecurityNumber = 999_99_9999L
val hexBytes = 0xFF_EC_DE_5E
val bytes = 0b11010010_01101001_10010100_10010010

---

3.比较两个数字

Kotlin 中没有基础数据类型，只有封装的数字类型，你每定义的一个变量，其实 Kotlin 帮你封装了一个对象，这样可以保证不会出现空指针。
数字类型也一样，所有在比较两个数字的时候，就有比较数据大小和比较两个对象是否相同的区别了。

fun main(args: Array<String>) {    val a: Int = 10000    println(a === a) // true，值相等，对象地址相等    //经过了装箱，创建了两个不同的对象    val boxedA: Int? = a    val anotherBoxedA: Int? = a    //虽然经过了装箱，但是值是相等的，都是10000    println(boxedA === anotherBoxedA) //  false，值相等，对象地址不一样    println(boxedA == anotherBoxedA) // true，值相等}

注意：如若a的值在[-128，127]之间并不会创建新的对象，println(boxedA === anotherBoxedA) 为** true，值相等，对象地址也一样，从128开始，比较结果才为**false

---

4.类型转换

由于不同的表示方式，较小类型并不是较大类型的子类型，较小的类型不能隐式转换为较大的类型。

val b: Byte = 1   // OK, 字面值是静态检测的val i: Int = b    // 错误

Kotlin中用toInt()方法

val b: Byte = 1 // OK, 字面值是静态检测的val i: Int = b.toInt() // OK

每种数据类型都有下面的这些方法，可以转化为其它的类型：

toByte(): BytetoShort(): ShorttoInt(): InttoLong(): LongtoFloat(): FloattoDouble(): DoubletoChar(): Char

有些情况下也是可以使用自动类型转化的，前提是可以根据上下文环境推断出正确的数据类型而且数学操作符会做相应的重载。例如下面是正确的：

val l = 1L + 3 // Long + Int => Long

---

5. 位操作符

对于Int和Long类型，还有一系列的位操作符可以使用，分别是：

shl(bits) – 左移位 (Java’s <<)shr(bits) – 右移位 (Java’s >>)ushr(bits) – 无符号右移位 (Java’s >>>)and(bits) – 与or(bits) – 或xor(bits) – 异或inv() – 反向

---

6.字符

和 Java 不一样，Kotlin 中的 Char 不能直接和数字操作，Char 必需是单引号”包含起来的。比如普通字符 ‘0’，’a’。

fun check(c: Char) {    if (c == 1) { // 错误：类型不兼容        // ……    }}

字符字面值用单引号括起来: ‘1’。 特殊字符可以用反斜杠转义。 支持这几个转义序列：\t、 \b、\n、\r、\’、\”、\ 和 $。 编码其他字符要用 Unicode 转义序列语法：’\uFF00’。

我们可以显式把字符转换为 Int 数字：

fun decimalDigitValue(c: Char): Int {    if (c !in '0'..'9')        throw IllegalArgumentException("Out of range")    return c.toInt() - '0'.toInt() // 显式转换为数字}

当需要可空引用时，像数字、字符会被装箱。装箱操作不会保留同一性。

布尔

布尔用 Boolean 类型表示，它有两个值：true 和 false。
若需要可空引用布尔会被装箱。
内置的布尔运算有：

|| ： 短路逻辑或&& ： 短路逻辑与! ： 逻辑非

---

数组

数组用类 Array 实现，并且还有一个 size 属性及 get 和 set 方法，由于使用 [] 重载了 get 和 set 方法，所以我们可以通过下标很方便的获取或者设置数组对应位置的值。

• 数组的创建两种方式：
  
  • 一种是使用函数arrayOf()；
  • 另外一种是使用工厂函数。

如下所示，我们分别是两种方式创建了两个数组：

fun main(args: Array<String>) {    //[1,2,3]    val a = arrayOf(1, 2, 3)    //[0,2,4]    val b = Array(3, { i -> (i * 2) })    //读取数组内容    println(a[0])    // 输出结果：1    println(b[1])    // 输出结果：2}

注意: 与 Java 不同的是，Kotlin 中数组是不型变的（invariant）。
除了类Array，还有ByteArray, ShortArray, IntArray，用来表示各个类型的数组，省去了装箱操作，因此效率更高，其用法同Array一样：

val x: IntArray = intArrayOf(1, 2, 3)x[0] = x[1] + x[2]

7.字符串

和 Java 一样，String 是可不变的。方括号 [] 语法可以很方便的获取字符串中的某个字符，也可以通过 for 循环来遍历：

for(c in str){    println(c)}

Kotlin 支持三个引号 “”” 扩起来的字符串，支持多行字符串，比如：

fun main(args: Array<String>){    val text = """    多行字符串    多行字符串    """    print(text)  // 输出有一些前置空格}

String 可以通过 trimMargin() 方法来删除多余的空白。

fun main(args: Array<String>) {    val text = """    |多行字符串    |多行字符串    """.trimMargin()    println(text)    // 前置空格删除了}

默认 | 用作边界前缀，但你可以选择其他字符并作为参数传入，比如 trimMargin(“>”)。

字符串模板

字符串可以包含模板表达式 ，即一些小段代码，会求值并把结果合并到字符串中。
模板表达式以美元符（$）开头，由一个简单的名字构成:

fun main(args: Array<String>) {    val i = 10    val s = "i = $i" // 求值结果为 "i = 10"    println(s)}

或者用花括号扩起来的任意表达式：

fun main(args: Array<String>) {    val s = "test"    val str = "$s.length is ${s.length}" // 求值结果为 "test.length is 4"    println(str)}

原生字符串和转义字符串内部都支持模板。 如果你需要在原生字符串中表示字面值 $ 字符（它不支持反斜杠转义），你可以用下列语法：

    fun main(args: Array<String>) {        val price = """        ${'$'}9.99        """        println(price)  // 求值结果为 $9.99    }

8.条件控制语句

if表达式

一个 if 语句包含一个布尔表达式和一条或多条语句。

// 传统用法var max = aif (a < b) max = b//使用 elsevar max: Intif (a > b){    max = a} else {    max = b}//作为表达式var max = if (a > b) a else b

我们也可以把 if 表达式的结果赋值给一个变量。

var max = if (a > b){    print("Choose a")    a} else {    print("Choose b")    b}

这也说明我也不需要像Java那种有一个三元操作符，因为我们可以使用它来简单实现：

var c = if (condition) a else b

使用区间
使用 in 运算符来检测某个数字是否在指定区间内，区间格式为 x..y ：
实例

fun main(args: Array<String>) {    val x = 5    if (x in 1..8) {        println("x 在区间内")    }}输出结果为：x 在区间内

when表达式

when 将它的参数和所有的分支条件顺序比较，直到某个分支满足条件。

• when 既可以被当做表达式使用也可以被当做语句使用。
  
  • 如果它被当做表达式，符合条件的分支的值就是整个表达式的值，
  • 如果当做语句使用， 则忽略个别分支的值。

when 类似其他语言的 switch 操作符。其最简单的形式如下：

when (x) {    1 -> print("x == 1")    2 -> print("x == 2")    else -> {       // 注意这个块        print("x 不是 1 ，也不是 2")    }}

在 when 中，else 同 switch 的 default。如果其他分支都不满足条件将会求值 else 分支。
如果很多分支需要用相同的方式处理，则可以把多个分支条件放在一起，用逗号分隔：

when (x) {    0, 1 -> print("x == 0 or x == 1")     else -> print("otherwise")}

我们也可以检测一个值在（in）或者不在（!in）一个区间或者集合中：

when (x) {    in 1..10 -> print("x is in the range")    in validNumbers -> print("x is valid")    !in 10..20 -> print("x is outside the range")    else -> print("none of the above")}

另一种可能性是检测一个值是（is）或者不是（!is）一个特定类型的值。
注意： 由于智能转换，你可以访问该类型的方法和属性而无需 任何额外的检测。

fun hasPrefix(x: Any) = when(x) {    is String -> x.startsWith("prefix")    else -> false}

when 也可以用来取代 if-else if链。 如果不提供参数，所有的分支条件都是简单的布尔表达式，而当一个分支的条件为真时则执行该分支：

when {    x.isOdd() -> print("x is odd")    x.isEven() -> print("x is even")    else -> print("x is funny")}

实例

fun main(args: Array<String>) {    var x = 0    when (x) {        0, 1 -> println("x == 0 or x == 1")        else -> println("otherwise")    }    when (x) {        1 -> println("x == 1")        2 -> println("x == 2")        else -> { // 注意这个块            println("x 不是 1 ，也不是 2")        }    }    when (x) {        in 0..10 -> println("x 在该区间范围内")        else -> println("x 不在该区间范围内")    }}

输出结果：

x == 0 or x == 1x 不是 1 ，也不是 2x 在该区间范围内

when 中使用 in 运算符来判断集合内是否包含某实例：

fun main(args: Array<String>) {    val items = setOf("apple", "banana", "kiwi")    when {        "orange" in items -> println("juicy")        "apple" in items -> println("apple is fine too")    }}输出结果：apple is fine too

9.循环控制

for循环

for 循环可以对任何提供迭代器（iterator）的对象进行遍历，语法如下:

for (item in collection) print(item)

循环体可以是一个代码块:

for (item: Int in ints) {    // ……}

如上所述，for 可以循环遍历任何提供了迭代器的对象。
如果你想要通过索引遍历一个数组或者一个 list，你可以这么做：

for (i in array.indices) {    print(array[i])}

注意这种”在区间上遍历”会编译成优化的实现而不会创建额外对象。
或者你可以用库函数 withIndex：

for ((index, value) in array.withIndex()) {    println("the element at $index is $value")}

实例
对集合进行迭代：

fun main(args: Array<String>) {    val items = listOf("apple", "banana", "kiwi")    for (item in items) {        println(item)    }    for (index in items.indices) {        println("item at $index is ${items[index]}")    }}

输出结果：

applebananakiwiitem at 0 is appleitem at 1 is bananaitem at 2 is kiwi

---

while 与 do…while 循环

while是最基本的循环，它的结构为：

while( 布尔表达式 ) {  //循环内容}

do…while 循环 对于 while 语句而言，如果不满足条件，则不能进入循环。
但 do…while 循环至少会执行一次。

do {    //代码语句}while(布尔表达式);

实例

fun main(args: Array<String>) {    println("----while 使用-----")    var x = 5    while (x > 0) {        print( x--)    }    println("----do...while 使用-----")    var y = 5    do {        println(y--)   //可以尝试 --y    } while(y>0)}输出结果：54321----do...while 使用-----54321

---

返回和跳转

• Kotlin 有三种结构化跳转表达式：
  
  • return。默认从最直接包围它的函数或者匿名函数返回。
  • break。终止最直接包围它的循环。
  • continue。继续下一次最直接包围它的循环。

在循环中 Kotlin 支持传统的 break 和 continue 操作符。

fun main(args: Array<String>) {    for (i in 1..10) {        if (i==3) continue  // i 为 3 时跳过当前循环，继续下一次循环        println(i)        if (i>5) break   // i 为 6 时 跳出循环    }}

输出结果：

12456

---

Break 和 Continue 标签

在 Kotlin 中任何表达式都可以用标签（label）来标记。
标签的格式为标识符后跟 @ 符号，例如：abc@、fooBar@都是有效的标签。 要为一个表达式加标签，我们只要在其前加标签即可。

loop@ for (i in 1..100) {    // ……}

现在，我们可以用标签限制 break 或者continue：

loop@ for (i in 1..100) {    for (j in 1..100) {        if (……) break@loop    }}

标签限制的 break 跳转到刚好位于该标签指定的循环后面的执行点。 continue 继续标签指定的循环的下一次迭代。

---

标签处返回

Kotlin 有函数字面量、局部函数和对象表达式。
因此 Kotlin 的函数可以被嵌套。 标签限制的 return 允许我们从外层函数返回。
最重要的一个用途就是从 lambda表达式中返回。回想一下我们这么写的时候：

fun foo() {    ints.forEach {        if (it == 0) return        print(it)    }}

这个 return 表达式从最直接包围它的函数即 foo 中返回。
（注意，这种非局部的返回只支持传给内联函数的 lambda 表达式。）
如果我们需要从 lambda 表达式中返回，我们必须给它加标签并用以限制 return。

fun foo() {    ints.forEach lit@ {        if (it == 0) return@lit        print(it)    }}

现在，它只会从 lambda 表达式中返回。
通常情况下使用隐式标签更方便。 该标签与接受该 lambda 的函数同名。

fun foo() {    ints.forEach {        if (it == 0) return@forEach        print(it)    }}

或者，我们用一个匿名函数替代 lambda 表达式。 匿名函数内部的 return 语句将从该匿名函数自身返回

fun foo() {    ints.forEach(fun(value: Int) {        if (value == 0) return        print(value)    })}

当要返一个回值的时候，解析器优先选用标签限制的 return，即

return@a 1

意为”从标签 @a 返回 1”，而不是”返回一个标签标注的表达式 (@a 1)”。

上述中：lambda表达式在Java SE 8中引进的新特性。
链接：Lambda简介（来自百度百科）

以上内容来自：http://www.runoob.com/kotlin/kotlin-tutorial.html
若以侵权，请发邮箱至[e-mail]我会立即删除。
尊重他人劳动成果，谨防盗版。