之前很早就想学一下Kotlin, 因为项目中用不到加上自身有点偷懒，所以一直没用付诸行动，但是Google宣布官方支持Kotlin以后，发觉真的有必要学习一下Kotlin了，本文是根据Kotlin官方中文教程所记得
一. 基础
1.1 基础类型
Kotlin不支持八进制
判断引用相等用
===;判断结构相等用==(即通常的值判断)数字装箱不会保留同一性,但保留相等性
val a: Int = 1000
val boxedA: Int? = a
val anotherBoxedA: Int? = a
print(boxedA === anotherBoxedA) //false, 判断引用是否相等
print(boxedA == anotherBoxedA) //true,判断值是否相等
- 较小的类型不能隐式转换为较大类型，如Int不能隐式转换为Long, 可以用显示转换拓宽数字:(每一个数字类型都支持以下操作)
toByte(): Byte
toShort(): Short
toInt(): Int
toLong(): Long
toFloat(); Float
toDouble(): Double
toChar(): Char
- 位运算只可用中缀方式调用命名函数
shl(bits) - 左移，跟Java的<<一样， (1 shl 2)
shr(bits) - 有符号右移，跟Java的>>一样， (1 shr 2)
ushr(bits) - 无符号右移， 跟Java的>>>一样
and(bits) - 位与
or(bits) - 位或
xor(bits) - 位异或
inv() - 位非
-
char类型不可以直接被当做数字，可以通过toInt()显示转换为数字 - 数组用
Array类来表示，Array类定义了set和get函数(按照运算符重载约定这会转变为[])和size属性
//创建数组
fun createArray() {
//创建了array[1, 2, 3]
val array = arrayOf(1, 2, 3)
//创建一个元素为Int类型，有3个元素的空数组
val nullArray = arrayOfNulls(3)
/* 第一个参数指定数组大小，第二个参数是一个函数，由该函数指定每个元素的初始值是多少*/
/* 创建一个["0", "1", "4", "9", "16"]的数组*/
val asc = Array(5, {i -> (i * i).toString()})
//用IntArray创建数组
val intArr = intArrayOf(1,2,3)
val intArr1: IntArray = intArrayOf(1, 2 ,3)
//用ByteArray创建数组
val byteArr: ByteArray = byteArrayOf(1, 2, 3)
//还可以创建ShortArray, LongArray等等
}
Kotlin中不允许把
Array赋值给Array
转义字符串，即Java中普通的字符串，其中可以包含转义字符如\n等，转义字符用
""括起来原生字符串，用两个
"""(三个引号)括起来，如"""abc\n"""，原生字符串内部不会转义，即使在内部有转义字符。也会当成普通字符处理字符串模板，字符串中可以包含*模板表达式, 即一小段代码，这一小段代码会求值并把结果合并到字符串中，模板表达式以美元符(
$)开头
val str = "abc"
/* 第一个模板是替换str为abc, 第二个模板是求出str的长度值然后拼接到字符串中
* 最后的输出是: abc.length is 3*/
val content = "$str.length is ${str.length}"
在原生字符串中也支持模板，如果想要在原生字符串中表示字面值
$，可以用以下方式：
val price = """ ${'$'}9.99"""
- 包名冲突时，可以使用
as关键字来重命名，该重命名只在当前源文件中有效
import foo.Bar
import bar.Bar as bBar
Kotlin中并没有
import static语法
1.2 控制流
if语句
- Kotlin中
if可以作为一个表达式，会返回一个值
val max = if (a > b) a else b
-
if的分支中也可以是代码块, 代码块中最后的表达式作为该代码块的值
fun max(a: Int, b: Int): Int {
val max = if (a > b) {
Log.d(TAG, "a is " + a)
a
} else {
Log.d(TAG, "b is " + b)
b
}
return max
}
when语句
-
when相当于switch, 一般用法为when(x) {...},when既可以当语句也可以当表达式，即返回一个值，当用作表达式时，返回的值是符合条件的分支的表达式的值(代码块中最后的表达式的值)
也可以用表达式来做为分支条件(因为表达式也会返回一个值)
如果when用作表达式，必须要有else分支
fun testWhen() {
var x: Int = 0
var x1: Int = 1
var x2: Int = 2
/* 普通when*/
when (x) {
1 -> Log.d(TAG, "1")
2 -> Log.d(TAG, "2")
else -> {
Log.d(TAG, "3")
}
}
/* 分支可以是表达式*/
var y: String = "10"
when (x) {
parseInt(y) -> Log.d(TAG, y) //先将y转换为Int,再判断x的值是否为y
else -> Log.d(TAG, "x is not y")
}
/* 检测一个值在不在区间*/
when (x) {
in 1..10 -> Log.d(TAG, "x is in 1..10")
!in 10..20 -> Log.d(TAG, "x is not in 10..20");
else -> Log.d(TAG, "x is neither in 1..10 nor in 10..20")
}
/* 如果when不提供参数，则分支表达式是布尔表达式*/
when {
x == x1 -> Log.d(TAG, "x equal x1")
x == x2 -> Log.d(TAG, "x equal x2")
else -> Log.d(TAG, "holy shit");
}
/* when当做表达式，还可以用is来检测是否是某个类型*/
val str = "prefixVar"
val hasPrefix: Boolean = when(y) {
is String -> y.startsWith("prefix")
else -> false
}
}
for 语句
-
for循环一般用in,如果想要通过索引遍历数组，使用indices，也可以使用库函数withIndex
fun testFor(array: Array) {
for (name in array) {
Log.d(TAG, name)
}
for (i in array.indices) {
Log.d(TAG, array[i])
}
for ((index, value) in array.withIndex()) {
Log.d(TAG, "Index is $index, value is $value")
}
}
break和continue
- break - 终止最直接包围他的循环
- continue - 继续下一次最直接包围他的循环
如果想终止或继续不是直接包围的循环，可以通过定义标签的形式来完成， 如：
loop1@ for (i in 1..5) {
loop2@ for (j in 10..20) {
if (j == 15) {
break@loop1 //直接终止了最外层循环
}
}
}
return
- return 默认从最直接包围他的函数或匿名函数返回
eg:
/* 直接从包围的函数testReturn中返回*/
fun testReturn(array: Array) {
array.forEach { if (it.startsWith(" ")) return }
}
如果想从lambda表达式中返回，可以通过标签的形式返回
/* 从lambda表达式中返回*/
fun testReturn1(array: Array) {
array.forEach label@{
if (it.startsWith(" ")) {
return@label
}
}
}
也可以通过匿名函数代替lambda表达式,这样return就可以直接从匿名函数自身中返回